public static String resolveQuery(CamelContext camelContext, String query, String placeholder)
            throws NoTypeConversionAvailableException, IOException {
        String answer = query;
        if (ResourceHelper.hasScheme(query)) {
            try (InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(camelContext, query)) {
                answer = camelContext.getTypeConverter().mandatoryConvertTo(String.class, is);
                if (placeholder != null) {
                    answer = answer.replaceAll(placeholder, "@");
                }
            }
        }
        return answer;
    }

    public static Expression fileExtensionExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.onlyExt(name);
            }

            @Override
            public String toString() {
                return "file:ext";
            }
        };
    }

    private void addMainListenerClass(Class<? extends MainListener>... listener) {
        StringJoiner existing = new StringJoiner(",");
        if (mainListenerClasses != null && !mainListenerClasses.isEmpty()) {
            existing.add(mainListenerClasses);
        }
        if (listener != null) {
            for (Class<? extends MainListener> clazz : listener) {
                existing.add(clazz.getName());
            }
        }
        setMainListenerClasses(existing.toString());
    }

    public String getLastChosenProcessorId() {
        int idx = getProcessor().getLastChosenProcessorIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

    public static Integer extractSourceLocationLineNumber(String location) {
        int cnt = StringHelper.countChar(location, ':');
        if (cnt > 0) {
            int pos = location.lastIndexOf(':');
             
            if (pos < location.length() - 1) {
                String num = location.substring(pos + 1);
                try {
                    return Integer.valueOf(num);
                } catch (Exception e) {
                    return null;
                }
            }
        }
        return null;
    }

    protected void execute(Exchange exchange, NitriteEndpoint endpoint) throws Exception {
        NitriteCollection collection = (NitriteCollection) endpoint.getNitriteCollection();
        if (filter != null && findOptions != null) {
            exchange.getMessage().setBody(collection.find(filter, findOptions));
        } else if (filter != null) {
            exchange.getMessage().setBody(collection.find(filter));
        } else {
            exchange.getMessage().setBody(collection.find());
        }

    }

    public boolean setProperty(
            CamelContext context, TypeConverter typeConverter, Object target, String name, Object value, String refName,
            boolean allowBuilderPattern, boolean allowPrivateSetter, boolean ignoreCase)
            throws Exception {
        invoked.incrementAndGet();
        if (!preStartDone || logger.shouldLog()) {
            Object text = value;
            if (SECRETS.matcher(name).find()) {
                text = "xxxxxx";
            }
            log("setProperty", target, name, text);
        }
        return IntrospectionSupport.setProperty(context, typeConverter, target, name, value, refName, allowBuilderPattern,
                allowPrivateSetter, ignoreCase);
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        Lock l = hazelcastInstance.getCPSubsystem().getLock(mapName);
        try {
            l.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            l.unlock();
        }
    }

    private boolean accept(String name) {
        if (stubPattern == null) {
            return true;
        }

        boolean stubbed = false;
        for (String n : stubPattern.split(",")) {
            if (n.startsWith("dataformat:")) {
                stubbed |= PatternHelper.matchPattern(name, n.substring(11));
            }
        }
        return !stubbed;
    }

    public void interceptProperties(Map<String, Object> properties) {
        Map<String, String> endpointHttpHeaders = (Map<String, String>) properties.get(ENDPOINT_HTTP_HEADERS_PROPERTY);

         
        properties.put(EDM_PROPERTY, apiProxy.getEdm(endpointHttpHeaders));

         
        properties.put(FILTER_ALREADY_SEEN, configuration.isFilterAlreadySeen());

         
        final String keyPredicate = (String) properties.get(KEY_PREDICATE_PROPERTY);
        if (keyPredicate != null) {

             
            properties.compute(RESOURCE_PATH_PROPERTY, (key, resourcePath) -> {
                if (resourcePath == null) {
                    throw new IllegalArgumentException(
                            "Resource path must be provided in endpoint URI, or URI parameter '" + RESOURCE_PATH_PROPERTY
                                                       + "', or exchange header '"
                                                       + Olingo4Constants.PROPERTY_PREFIX + RESOURCE_PATH_PROPERTY + "'");
                }

                 
                return resourcePath + "(" + keyPredicate + ")";
            });
        }

         
        parseQueryParams(properties);
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    private void addRoutePolicyFactories() {
        Map<String, RoutePolicyFactory> routePolicyFactories
                = getContext().getRegistry().findByTypeWithName(RoutePolicyFactory.class);
        if (routePolicyFactories != null && !routePolicyFactories.isEmpty()) {
            for (Entry<String, RoutePolicyFactory> entry : routePolicyFactories.entrySet()) {
                RoutePolicyFactory factory = entry.getValue();
                LOG.info("Using custom RoutePolicyFactory with id: {} and implementation: {}", entry.getKey(), factory);
                getContext().addRoutePolicyFactory(factory);
            }
        }
    }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        GzipCompressorInputStream unzipInput = null;

        OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);
        try {
            unzipInput = new GzipCompressorInputStream(inputStream, true);
            IOHelper.copy(unzipInput, osb);
            return osb.build();
        } finally {
             
            IOHelper.close(osb, unzipInput, inputStream);
        }
    }

    public static InvokeModelWithResponseStreamResponseHandler createChunksHandler(
            String modelId,
            StreamMetadata metadata,
            List<String> chunks,
            Consumer<String> chunkConsumer) {

        StreamResponseParser parser = StreamParserFactory.getParser(modelId);
        int[] chunkCount = { 0 };

        return InvokeModelWithResponseStreamResponseHandler.builder()
                .subscriber(InvokeModelWithResponseStreamResponseHandler.Visitor.builder()
                        .onChunk(part -> {
                            try {
                                String chunkJson = part.bytes().asUtf8String();
                                String text = parser.extractText(chunkJson);

                                if (text != null && !text.isEmpty()) {
                                    chunks.add(text);
                                    if (chunkConsumer != null) {
                                        chunkConsumer.accept(text);
                                    }
                                }

                                 
                                if (parser.isFinalChunk(chunkJson)) {
                                    String completionReason = parser.extractCompletionReason(chunkJson);
                                    if (completionReason != null) {
                                        metadata.setCompletionReason(completionReason);
                                    }

                                    Integer tokenCount = parser.extractTokenCount(chunkJson);
                                    if (tokenCount != null) {
                                        metadata.setTokenCount(tokenCount);
                                    }
                                }
                                chunkCount[0]++;
                            } catch (JsonProcessingException e) {
                                LOG.warn("Error parsing streaming chunk: {}", e.getMessage(), e);
                            }
                        })
                        .build())
                .onComplete(() -> {
                    metadata.setChunkCount(chunkCount[0]);
                    metadata.setChunks(chunks);
                })
                .build();
    }

    public static JsonObject asJsonObject(LanguageModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("modelName", model.getModelName());
        obj.put("modelJavaType", model.getModelJavaType());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("language", obj);
        wrapper.put("properties", asJsonObject(model.getOptions()));
        final List<LanguageModel.LanguageFunctionModel> functions = model.getFunctions();
        if (!functions.isEmpty()) {
            wrapper.put("functions", asJsonObjectFunctions(functions));
        }
        return wrapper;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "apexMethod": getOrCreateConfiguration((SalesforceComponent) component).setApexMethod((java.lang.String) value); return true;
            case "apexQueryParams": getOrCreateConfiguration((SalesforceComponent) component).setApexQueryParams((java.util.Map) value); return true;
            case "apiVersion": getOrCreateConfiguration((SalesforceComponent) component).setApiVersion((java.lang.String) value); return true;
            case "backoffIncrement": getOrCreateConfiguration((SalesforceComponent) component).setBackoffIncrement((long) value); return true;
            case "batchId": getOrCreateConfiguration((SalesforceComponent) component).setBatchId((java.lang.String) value); return true;
            case "contentType": getOrCreateConfiguration((SalesforceComponent) component).setContentType((org.apache.camel.component.salesforce.api.dto.bulk.ContentType) value); return true;
            case "defaultReplayId": getOrCreateConfiguration((SalesforceComponent) component).setDefaultReplayId((java.lang.Long) value); return true;
            case "fallBackReplayId": getOrCreateConfiguration((SalesforceComponent) component).setFallBackReplayId((java.lang.Long) value); return true;
            case "format": getOrCreateConfiguration((SalesforceComponent) component).setFormat((org.apache.camel.component.salesforce.internal.PayloadFormat) value); return true;
            case "httpClient": getOrCreateConfiguration((SalesforceComponent) component).setHttpClient((org.apache.camel.component.salesforce.SalesforceHttpClient) value); return true;
            case "httpClientConnectionTimeout": ((SalesforceComponent) component).setHttpClientConnectionTimeout((long) value); return true;
            case "httpClientIdleTimeout": ((SalesforceComponent) component).setHttpClientIdleTimeout((long) value); return true;
            case "httpMaxContentLength": ((SalesforceComponent) component).setHttpMaxContentLength((java.lang.Integer) value); return true;
            case "httpRequestBufferSize": ((SalesforceComponent) component).setHttpRequestBufferSize((java.lang.Integer) value); return true;
            case "httpRequestTimeout": ((SalesforceComponent) component).setHttpRequestTimeout((long) value); return true;
            case "includeDetails": getOrCreateConfiguration((SalesforceComponent) component).setIncludeDetails((java.lang.Boolean) value); return true;
            case "initialReplayIdMap": getOrCreateConfiguration((SalesforceComponent) component).setInitialReplayIdMap((java.util.Map) value); return true;
            case "instanceId": getOrCreateConfiguration((SalesforceComponent) component).setInstanceId((java.lang.String) value); return true;
            case "jobId": getOrCreateConfiguration((SalesforceComponent) component).setJobId((java.lang.String) value); return true;
            case "limit": getOrCreateConfiguration((SalesforceComponent) component).setLimit((java.lang.Integer) value); return true;
            case "locator": getOrCreateConfiguration((SalesforceComponent) component).setLocator((java.lang.String) value); return true;
            case "maxBackoff": getOrCreateConfiguration((SalesforceComponent) component).setMaxBackoff((long) value); return true;
            case "maxRecords": getOrCreateConfiguration((SalesforceComponent) component).setMaxRecords((java.lang.Integer) value); return true;
            case "notFoundBehaviour": getOrCreateConfiguration((SalesforceComponent) component).setNotFoundBehaviour((org.apache.camel.component.salesforce.NotFoundBehaviour) value); return true;
            case "notifyForFields": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForFields((org.apache.camel.component.salesforce.internal.dto.NotifyForFieldsEnum) value); return true;
            case "notifyForOperationCreate": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationCreate((java.lang.Boolean) value); return true;
            case "notifyForOperationDelete": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationDelete((java.lang.Boolean) value); return true;
            case "notifyForOperations": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperations((org.apache.camel.component.salesforce.internal.dto.NotifyForOperationsEnum) value); return true;
            case "notifyForOperationUndelete": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationUndelete((java.lang.Boolean) value); return true;
            case "notifyForOperationUpdate": getOrCreateConfiguration((SalesforceComponent) component).setNotifyForOperationUpdate((java.lang.Boolean) value); return true;
            case "objectMapper": getOrCreateConfiguration((SalesforceComponent) component).setObjectMapper((com.fasterxml.jackson.databind.ObjectMapper) value); return true;
            case "packages": ((SalesforceComponent) component).setPackages((java.lang.String) value); return true;
            case "pkChunking": getOrCreateConfiguration((SalesforceComponent) component).setPkChunking((java.lang.Boolean) value); return true;
            case "pkChunkingChunkSize": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingChunkSize((java.lang.Integer) value); return true;
            case "pkChunkingParent": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingParent((java.lang.String) value); return true;
            case "pkChunkingStartRow": getOrCreateConfiguration((SalesforceComponent) component).setPkChunkingStartRow((java.lang.String) value); return true;
            case "queryLocator": getOrCreateConfiguration((SalesforceComponent) component).setQueryLocator((java.lang.String) value); return true;
            case "rawPayload": getOrCreateConfiguration((SalesforceComponent) component).setRawPayload((boolean) value); return true;
            case "reportId": getOrCreateConfiguration((SalesforceComponent) component).setReportId((java.lang.String) value); return true;
            case "reportMetadata": getOrCreateConfiguration((SalesforceComponent) component).setReportMetadata((org.apache.camel.component.salesforce.api.dto.analytics.reports.ReportMetadata) value); return true;
            case "resultId": getOrCreateConfiguration((SalesforceComponent) component).setResultId((java.lang.String) value); return true;
            case "sObjectBlobFieldName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectBlobFieldName((java.lang.String) value); return true;
            case "sObjectClass": getOrCreateConfiguration((SalesforceComponent) component).setSObjectClass((java.lang.String) value); return true;
            case "sObjectFields": getOrCreateConfiguration((SalesforceComponent) component).setSObjectFields((java.lang.String) value); return true;
            case "sObjectId": getOrCreateConfiguration((SalesforceComponent) component).setSObjectId((java.lang.String) value); return true;
            case "sObjectIdName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectIdName((java.lang.String) value); return true;
            case "sObjectIdValue": getOrCreateConfiguration((SalesforceComponent) component).setSObjectIdValue((java.lang.String) value); return true;
            case "sObjectName": getOrCreateConfiguration((SalesforceComponent) component).setSObjectName((java.lang.String) value); return true;
            case "sObjectQuery": getOrCreateConfiguration((SalesforceComponent) component).setSObjectQuery((java.lang.String) value); return true;
            case "sObjectSearch": getOrCreateConfiguration((SalesforceComponent) component).setSObjectSearch((java.lang.String) value); return true;
            case "streamQueryResult": getOrCreateConfiguration((SalesforceComponent) component).setStreamQueryResult((java.lang.Boolean) value); return true;
            case "updateTopic": getOrCreateConfiguration((SalesforceComponent) component).setUpdateTopic((boolean) value); return true;
            case "config": ((SalesforceComponent) component).setConfig((org.apache.camel.component.salesforce.SalesforceEndpointConfig) value); return true;
            case "httpClientProperties": ((SalesforceComponent) component).setHttpClientProperties((java.util.Map) value); return true;
            case "longPollingTransportProperties": ((SalesforceComponent) component).setLongPollingTransportProperties((java.util.Map) value); return true;
            case "workerPoolMaxSize": ((SalesforceComponent) component).setWorkerPoolMaxSize((int) value); return true;
            case "workerPoolSize": ((SalesforceComponent) component).setWorkerPoolSize((int) value); return true;
            case "bridgeErrorHandler": ((SalesforceComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "fallbackToLatestReplayId": getOrCreateConfiguration((SalesforceComponent) component).setFallbackToLatestReplayId((boolean) value); return true;
            case "pubSubBatchSize": getOrCreateConfiguration((SalesforceComponent) component).setPubSubBatchSize((int) value); return true;
            case "pubSubDeserializeType": getOrCreateConfiguration((SalesforceComponent) component).setPubSubDeserializeType((org.apache.camel.component.salesforce.PubSubDeserializeType) value); return true;
            case "pubSubPojoClass": getOrCreateConfiguration((SalesforceComponent) component).setPubSubPojoClass((java.lang.String) value); return true;
            case "replayPreset": getOrCreateConfiguration((SalesforceComponent) component).setReplayPreset((com.salesforce.eventbus.protobuf.ReplayPreset) value); return true;
            case "consumerWorkerPoolEnabled": ((SalesforceComponent) component).setConsumerWorkerPoolEnabled((boolean) value); return true;
            case "consumerWorkerPoolExecutorService": ((SalesforceComponent) component).setConsumerWorkerPoolExecutorService((java.util.concurrent.ExecutorService) value); return true;
            case "consumerWorkerPoolMaxSize": ((SalesforceComponent) component).setConsumerWorkerPoolMaxSize((int) value); return true;
            case "consumerWorkerPoolSize": ((SalesforceComponent) component).setConsumerWorkerPoolSize((int) value); return true;
            case "initialReplyIdTimeout": ((SalesforceComponent) component).setInitialReplyIdTimeout((int) value); return true;
            case "allOrNone": getOrCreateConfiguration((SalesforceComponent) component).setAllOrNone((boolean) value); return true;
            case "apexUrl": getOrCreateConfiguration((SalesforceComponent) component).setApexUrl((java.lang.String) value); return true;
            case "compositeMethod": getOrCreateConfiguration((SalesforceComponent) component).setCompositeMethod((java.lang.String) value); return true;
            case "eventName": getOrCreateConfiguration((SalesforceComponent) component).setEventName((java.lang.String) value); return true;
            case "eventSchemaFormat": getOrCreateConfiguration((SalesforceComponent) component).setEventSchemaFormat((org.apache.camel.component.salesforce.internal.dto.EventSchemaFormatEnum) value); return true;
            case "eventSchemaId": getOrCreateConfiguration((SalesforceComponent) component).setEventSchemaId((java.lang.String) value); return true;
            case "lazyStartProducer": ((SalesforceComponent) component).setLazyStartProducer((boolean) value); return true;
            case "rawHttpHeaders": getOrCreateConfiguration((SalesforceComponent) component).setRawHttpHeaders((java.lang.String) value); return true;
            case "rawMethod": getOrCreateConfiguration((SalesforceComponent) component).setRawMethod((java.lang.String) value); return true;
            case "rawPath": getOrCreateConfiguration((SalesforceComponent) component).setRawPath((java.lang.String) value); return true;
            case "rawQueryParameters": getOrCreateConfiguration((SalesforceComponent) component).setRawQueryParameters((java.lang.String) value); return true;
            case "autowiredEnabled": ((SalesforceComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "httpProxyExcludedAddresses": ((SalesforceComponent) component).setHttpProxyExcludedAddresses((java.util.Set) value); return true;
            case "httpProxyHost": ((SalesforceComponent) component).setHttpProxyHost((java.lang.String) value); return true;
            case "httpProxyIncludedAddresses": ((SalesforceComponent) component).setHttpProxyIncludedAddresses((java.util.Set) value); return true;
            case "httpProxyPort": ((SalesforceComponent) component).setHttpProxyPort((java.lang.Integer) value); return true;
            case "httpProxySocks4": ((SalesforceComponent) component).setHttpProxySocks4((boolean) value); return true;
            case "pubsubAllowUseSystemProxy": ((SalesforceComponent) component).setPubsubAllowUseSystemProxy((boolean) value); return true;
            case "authenticationType": ((SalesforceComponent) component).setAuthenticationType((org.apache.camel.component.salesforce.AuthenticationType) value); return true;
            case "clientId": ((SalesforceComponent) component).setClientId((java.lang.String) value); return true;
            case "clientSecret": ((SalesforceComponent) component).setClientSecret((java.lang.String) value); return true;
            case "httpProxyAuthUri": ((SalesforceComponent) component).setHttpProxyAuthUri((java.lang.String) value); return true;
            case "httpProxyPassword": ((SalesforceComponent) component).setHttpProxyPassword((java.lang.String) value); return true;
            case "httpProxyRealm": ((SalesforceComponent) component).setHttpProxyRealm((java.lang.String) value); return true;
            case "httpProxySecure": ((SalesforceComponent) component).setHttpProxySecure((boolean) value); return true;
            case "httpProxyUseDigestAuth": ((SalesforceComponent) component).setHttpProxyUseDigestAuth((boolean) value); return true;
            case "httpProxyUsername": ((SalesforceComponent) component).setHttpProxyUsername((java.lang.String) value); return true;
            case "instanceUrl": ((SalesforceComponent) component).setInstanceUrl((java.lang.String) value); return true;
            case "jwtAudience": ((SalesforceComponent) component).setJwtAudience((java.lang.String) value); return true;
            case "keystore": ((SalesforceComponent) component).setKeystore((org.apache.camel.support.jsse.KeyStoreParameters) value); return true;
            case "lazyLogin": ((SalesforceComponent) component).setLazyLogin((boolean) value); return true;
            case "loginConfig": ((SalesforceComponent) component).setLoginConfig((org.apache.camel.component.salesforce.SalesforceLoginConfig) value); return true;
            case "loginUrl": ((SalesforceComponent) component).setLoginUrl((java.lang.String) value); return true;
            case "password": ((SalesforceComponent) component).setPassword((java.lang.String) value); return true;
            case "pubSubHost": ((SalesforceComponent) component).setPubSubHost((java.lang.String) value); return true;
            case "pubSubPort": ((SalesforceComponent) component).setPubSubPort((int) value); return true;
            case "refreshToken": ((SalesforceComponent) component).setRefreshToken((java.lang.String) value); return true;
            case "sslContextParameters": ((SalesforceComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "useGlobalSslContextParameters": ((SalesforceComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            case "userName": ((SalesforceComponent) component).setUserName((java.lang.String) value); return true;
            default: return false;
            }
        }

    private String getLoad(Row r) {
        String s1 = r.load01 != null ? r.load01 : "-";
        String s2 = r.load05 != null ? r.load05 : "-";
        String s3 = r.load15 != null ? r.load15 : "-";
        if ("0.00".equals(s1)) {
            s1 = "-";
        }
        if ("0.00".equals(s2)) {
            s2 = "-";
        }
        if ("0.00".equals(s3)) {
            s3 = "-";
        }
        if (s1.equals("-") && s2.equals("-") && s3.equals("-")) {
            return "0/0/0";
        }
        return s1 + "/" + s2 + "/" + s3;
    }

    private void doHttpRequestWithJobResponse(JobResponseCallback callback, Request request) {
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                Job responseJob = null;
                try {
                    responseJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            Job.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, responseHeaders, ex);
            }
        });
    }

    public KeyPair importKey(byte[] keyData, KeyFormat format, String algorithm) throws Exception {
         
        try {
            PrivateKey privateKey = KeyFormatConverter.importPrivateKey(keyData, format, getAlgorithmName(algorithm));
            LOG.warn("Importing private key only - public key derivation may be needed");
            return new KeyPair(null, privateKey);
        } catch (Exception e) {
             
            PublicKey publicKey = KeyFormatConverter.importPublicKey(keyData, format, getAlgorithmName(algorithm));
            return new KeyPair(publicKey, null);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator != null) {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                             
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            } else {
                super.process(exchange, doneSync -> callback.done(false));
            }
        }));
        return false;
    }

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    protected Connector getSocketConnector(Server server, JettyHttpEndpoint endpoint) {
        Connector answer = null;
        if (socketConnectors != null) {
            answer = socketConnectors.get(endpoint.getPort());
        }
        if (answer == null) {
            answer = createConnector(server, endpoint);
        }
        return answer;
    }

    private void processGetAllBatches(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getAllBatches(jobId, determineHeaders(exchange), new BulkApiClient.BatchInfoListResponseCallback() {
            @Override
            public void onResponse(List<BatchInfo> batchInfoList, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfoList, headers, ex, callback);
            }
        });
    }

        public Destination resolveDestinationName(
                Session session, String destinationName,
                boolean pubSubDomain)
                throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.resolveDestinationName(session, destinationName, pubSubDomain);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    protected boolean isBanned(ClassInfo ci) {
        if (bannedDefinitions != null) {
            for (String bannedDefinition : bannedDefinitions) {
                if (AntPathMatcher.INSTANCE.match(bannedDefinition.replace('.', '/'), ci.name().toString('/'))) {
                    getLog().debug("Skipping definition: " + ci.name().toString());
                    return true;
                }
            }
        }

        return false;
    }

        DateTimeFormatter getDateFormat() {
            DateTimeFormatter result;
            if (locale != null) {
                result = DateTimeFormatter.ofPattern(pattern, locale)
                        .withZone(zone);
            } else {
                result = DateTimeFormatter.ofPattern(pattern)
                        .withZone(zone);
            }
            return result;
        }

    public BeanConstructorsDefinition marshal(Map<Integer, Object> v) {
        if (v == null) {
            return null;
        }
        final BeanConstructorDefinition[] result = new BeanConstructorDefinition[v.size()];
        int pos = 0;
        for (Map.Entry<Integer, Object> entry : v.entrySet()) {
            Integer idx = entry.getKey();
            Object value = entry.getValue();
            BeanConstructorDefinition pd = new BeanConstructorDefinition();
            if (idx != null) {
                pd.setIndex(idx);
            }
            pd.setValue(value.toString());
            result[pos++] = pd;
        }
        BeanConstructorsDefinition def = new BeanConstructorsDefinition();
        def.setConstructors(Arrays.asList(result));
        return def;
    }

    public void execute(Exchange exchange) throws SmppException {
        byte[] message = getShortMessage(exchange.getIn());

        ReplaceSm replaceSm = createReplaceSmTempate(exchange);
        replaceSm.setShortMessage(message);

        if (log.isDebugEnabled()) {
            log.debug("Sending replacement command for a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), replaceSm.getMessageId());
        }

        try {
            session.replaceShortMessage(
                    replaceSm.getMessageId(),
                    TypeOfNumber.valueOf(replaceSm.getSourceAddrTon()),
                    NumberingPlanIndicator.valueOf(replaceSm.getSourceAddrNpi()),
                    replaceSm.getSourceAddr(),
                    replaceSm.getScheduleDeliveryTime(),
                    replaceSm.getValidityPeriod(),
                    new RegisteredDelivery(replaceSm.getRegisteredDelivery()),
                    replaceSm.getSmDefaultMsgId(),
                    replaceSm.getShortMessage());
        } catch (Exception e) {
            throw new SmppException(e);
        }

        if (log.isDebugEnabled()) {
            log.debug("Sent replacement command for a short message for exchange id '{}' and message id '{}'",
                    exchange.getExchangeId(), replaceSm.getMessageId());
        }

        Message rspMsg = ExchangeHelper.getResultMessage(exchange);
        rspMsg.setHeader(SmppConstants.ID, replaceSm.getMessageId());
    }

    protected RouteDefinition createRoute() {
        RouteDefinition route = new RouteDefinition();
        route.setCamelContext(getCamelContext());
        ErrorHandlerFactory handler = getErrorHandlerFactory();
        if (handler != null) {
            route.setErrorHandlerFactoryIfNull(handler);
        }
        if (resource != null) {
            route.setResource(resource);
        }
        return route;
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getConfiguration().hasQueryBuilder()) {
            handler = new ContinuousQueryHandler();
        } else {
            handler = new ConsumerHandler();
        }

        ServiceHelper.startService(handler);
    }

    public RemoteFileOperations<FTPFile> createRemoteFileOperations() throws Exception {
         
        FTPClient client = ftpClient;

        if (client == null) {
             
             
            client = createFtpClient();
        }

         
         
        if (getBufferSize() > 0) {
            client.setBufferSize(getBufferSize());
        }
         
        if (getConfiguration().getConnectTimeout() > -1) {
            client.setConnectTimeout(getConfiguration().getConnectTimeout());
        }
        if (getConfiguration().getSoTimeout() > -1) {
            soTimeout = getConfiguration().getSoTimeout();
        }
        dataTimeout = getConfiguration().getTimeout();

        if (getConfiguration().getActivePortRange() != null) {
             
            String[] parts = getConfiguration().getActivePortRange().split("-");
            if (parts.length != 2) {
                throw new IllegalArgumentException("The option activePortRange should have syntax: min-max");
            }
            int min = getCamelContext().getTypeConverter().mandatoryConvertTo(int.class, parts[0]);
            int max = getCamelContext().getTypeConverter().mandatoryConvertTo(int.class, parts[1]);
            LOG.debug("Using active port range: {}-{}", min, max);
            client.setActivePortRange(min, max);
        }

         
        if (ftpClientParameters != null) {
            Map<String, Object> localParameters = new HashMap<>(ftpClientParameters);
             
             
            Object timeout = localParameters.remove("soTimeout");
            if (timeout != null) {
                soTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
             
            timeout = localParameters.remove("dataTimeout");
            if (timeout != null) {
                dataTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
            setProperties(client, localParameters);
        }

        if (ftpClientConfigParameters != null) {
             
             
            if (ftpClientConfig == null) {
                ftpClientConfig = new FTPClientConfig();
            }
            Map<String, Object> localConfigParameters = new HashMap<>(ftpClientConfigParameters);
            setProperties(ftpClientConfig, localConfigParameters);
        }

        if (dataTimeout > 0) {
            client.setDataTimeout(dataTimeout);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Created FTPClient[connectTimeout: {}, soTimeout: {}, dataTimeout: {}, bufferSize: {}"
                      + ", receiveDataSocketBufferSize: {}, sendDataSocketBufferSize: {}]: {}",
                    client.getConnectTimeout(), getSoTimeout(), dataTimeout, client.getBufferSize(),
                    client.getReceiveDataSocketBufferSize(), client.getSendDataSocketBufferSize(), client);
        }

        FtpOperations operations = new FtpOperations(client, getFtpClientConfig());
        operations.setEndpoint(this);
        return operations;
    }

    private CachingInjector<?> handleHasConverterAnnotation(
            TypeConverterRegistry registry, Class<?> type,
            CachingInjector<?> injector, Method method, boolean allowNull) {
        if (isValidConverterMethod(method)) {
            int modifiers = method.getModifiers();
            if (isAbstract(modifiers) || !isPublic(modifiers)) {
                LOG.warn(
                        "Ignoring bad converter on type: {} method: {} as a converter method is not a public and concrete method",
                        type.getCanonicalName(), method);
            } else {
                Class<?> toType = method.getReturnType();
                if (toType.equals(Void.class)) {
                    LOG.warn("Ignoring bad converter on type: {} method: {} as a converter method returns a void method",
                            type.getCanonicalName(), method);
                } else {
                    Class<?> fromType = method.getParameterTypes()[0];
                    if (isStatic(modifiers)) {
                        registerTypeConverter(registry, method, toType, fromType,
                                new StaticMethodTypeConverter(method, allowNull));
                    } else {
                        if (injector == null) {
                            injector = new CachingInjector<>(registry, CastUtils.cast(type, Object.class));
                        }
                        registerTypeConverter(registry, method, toType, fromType,
                                new InstanceMethodTypeConverter(injector, method, registry, allowNull));
                    }
                }
            }
        } else {
            LOG.warn("Ignoring bad converter on type: {} method: {} as a converter method should have one parameter",
                    type.getCanonicalName(), method);
        }
        return injector;
    }

    protected void initialize() {
         
         
        getOutFilter().add(JmsConstants.JMS_HEADER_XUSER_ID);
        getOutFilter().add("JMSXAppID");
        getOutFilter().add("JMSXDeliveryCount");
        getOutFilter().add("JMSXProducerTXID");
        getOutFilter().add("JMSXConsumerTXID");
        getOutFilter().add("JMSXRcvTimestamp");
        getOutFilter().add("JMSXRecvTimestamp");
        getOutFilter().add("JMSXState");
    }

    public void onExchangeDone(Exchange exchange) {
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeDone(exchange);
            }
        } else {
            super.onExchangeDone(exchange);
        }
    }

    public <T extends Enum<T>> T getEnum(final String key) throws ClassNotFoundException {
         
        T returnable;
        final String value;
        final String[] splitValues;
        final int numberOfSplitValues;
        final StringBuilder returnTypeName;
        final StringBuilder enumName;
        final Class<T> returnType;
         
        value = this.getStringOrDefault(key, "");
        if (value == null) {
            return null;
        }
         
        splitValues = value.split("\\.");
        numberOfSplitValues = splitValues.length;
        returnTypeName = new StringBuilder();
        enumName = new StringBuilder();
        for (int i = 0; i < numberOfSplitValues; i++) {
            if (i == (numberOfSplitValues - 1)) {
                 
                enumName.append(splitValues[i]);
            } else if (i == (numberOfSplitValues - 2)) {
                 
                returnTypeName.append(splitValues[i]);
            } else {
                 
                returnTypeName.append(splitValues[i]);
                returnTypeName.append(".");
            }
        }
         
        returnType = (Class<T>) Class.forName(returnTypeName.toString());
        returnable = Enum.valueOf(returnType, enumName.toString());
        return returnable;
    }

    public String parseCode() {
        try {
            parseTokens();
            return doParseCode();
        } catch (SimpleParserException e) {
             
            throw new SimpleIllegalSyntaxException(expression, e.getIndex(), e.getMessage(), e);
        } catch (Exception e) {
             
            throw new SimpleIllegalSyntaxException(expression, -1, e.getMessage(), e);
        }
    }

    public static List<RestConfigurationDetails> parseRestConfiguration(
            JavaClassSource clazz, String fullyQualifiedFileName,
            boolean includeInlinedRouteBuilders) {

        List<MethodSource<JavaClassSource>> methods = findAllConfigureMethods(clazz, includeInlinedRouteBuilders);

        CamelJavaRestDslParserHelper parser = new CamelJavaRestDslParserHelper();
        List<RestConfigurationDetails> list = new ArrayList<>();
        for (MethodSource<JavaClassSource> configureMethod : methods) {
             
            List<RestConfigurationDetails> details
                    = parser.parseRestConfiguration(clazz, fullyQualifiedFileName, configureMethod);
            list.addAll(details);
        }
         
        Collections.reverse(list);

        return list;
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof int[]) {
            int[] seed = exchange.getIn().getBody(int[].class);
            Image[] result = predict(exchange, seed);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be int[]");
        }
    }

    private String extractPlatform(ProcessHandle ph, JsonObject runtime) {
        String answer = runtime != null ? runtime.getString("platform") : null;
        if ("Camel".equals(answer)) {
             
            String cl = ph.info().commandLine().orElse("");
            if (cl.contains("main.CamelJBang run")) {
                answer = "JBang";
            }
        }
        return answer;
    }

    protected LongHistogram getInstrument(String name, String description) {
        LongHistogram timer = timers.get(name);
        if (timer == null) {
            synchronized (lock) {
                timer = timers.get(name);
                if (timer == null) {
                    Meter meter = getEndpoint().getMeter();
                    LongHistogramBuilder builder = meter.histogramBuilder(name).ofLongs();
                    if (description != null) {
                        builder.setDescription(description);
                    }
                    builder.setUnit(getEndpoint().getUnit().name().toLowerCase());
                    timer = builder.build();
                    timers.put(name, timer);
                }
            }
        }
        return timer;
    }

    public DataLakeOperationResponse listPaths(final Exchange exchange) {
        final ListPathsOptions listPathsOptions = configurationProxy.getListPathOptions(exchange);
        final Duration timeout = configurationProxy.getTimeout(exchange);
        final String regex = configurationProxy.getRegex(exchange);
        List<PathItem> paths = client.listPaths(listPathsOptions, timeout);

        if (ObjectHelper.isEmpty(regex)) {
            return new DataLakeOperationResponse(paths);
        } else {
            List<PathItem> filteredPaths = paths.stream()
                    .filter(x -> x.getName().matches(regex))
                    .collect(Collectors.toCollection(LinkedList<PathItem>::new));
            return new DataLakeOperationResponse(filteredPaths);
        }
    }

    private void processGetResults(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody;
        String batchId;
        batchBody = exchange.getIn().getBody(BatchInfo.class);
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getResults(jobId, batchId, determineHeaders(exchange), new BulkApiClient.StreamResponseCallback() {
            @Override
            public void onResponse(InputStream inputStream, Map<String, String> headers, SalesforceException ex) {
                 
                 
                StreamCache body = null;
                if (inputStream != null) {
                    try {
                        body = StreamCacheConverter.convertToStreamCache(inputStream, exchange);
                    } catch (IOException e) {
                        String msg = "Error retrieving batch results: " + e.getMessage();
                        ex = new SalesforceException(msg, e);
                    } finally {
                         
                        try {
                            inputStream.close();
                        } catch (IOException ignore) {
                        }
                    }
                }
                processResponse(exchange, body, headers, ex, callback);
            }
        });
    }

    public void initialize(Server server, Bus bus) {
        server.getEndpoint().put("org.apache.cxf.binding.soap.addNamespaceContext", "true");
        server.getEndpoint().getBinding().getInInterceptors().add(new ConfigureDocLitWrapperInterceptor(true));
        if (server.getEndpoint().getBinding() instanceof SoapBinding) {
            server.getEndpoint().getBinding().getOutInterceptors().add(new SetSoapVersionInterceptor());
        }
         
         
        removeInterceptor(server.getEndpoint().getInInterceptors(),
                HolderInInterceptor.class);
        removeInterceptor(server.getEndpoint().getOutInterceptors(),
                HolderOutInterceptor.class);
        removeInterceptor(server.getEndpoint().getBinding().getInInterceptors(),
                SoapHeaderInterceptor.class);
        resetPartTypes(server.getEndpoint().getBinding());

        LOG.info("Initialized CXF Server: {} in Payload mode with allow streaming: {}", server, allowStreaming);
    }

    <T> Optional<T> tryToReadResponse(final Class<T> expectedType, final InputStream responseStream) {
        if (responseStream == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(fromJson(expectedType, responseStream));
        } catch (IOException e) {
            log.warn("Unable to read response from the Composite API", e);
            return Optional.empty();
        } finally {
            IOHelper.close(responseStream);
        }
    }

    protected Class<?> getResponseModel(Message message, String modelName) {
        Class<?> model = null;

        if (message != null) {
            model = message.getHeader(ServiceNowConstants.RESPONSE_MODEL, Class.class);
            if (model == null) {
                model = message.getHeader(ServiceNowConstants.MODEL, Class.class);
            }
        }

        return model != null
                ? model
                : ObjectHelper.isEmpty(modelName) ? Map.class : config.getResponseModel(modelName, Map.class);
    }

    public HttpBinding getHttpBinding() {
         
        if (this.binding == null) {
            this.binding = new AttachmentHttpBinding();
            this.binding.setTransferException(isTransferException());
            this.binding.setMuteException(isMuteException());
            this.binding.setLogException(isLogException());
            if (getComponent() != null) {
                this.binding.setAllowJavaSerializedObject(getComponent().isAllowJavaSerializedObject());
            }
            this.binding.setHeaderFilterStrategy(getHeaderFilterStrategy());
            this.binding.setEagerCheckContentAvailable(isEagerCheckContentAvailable());
            this.binding.setMapHttpMessageBody(isMapHttpMessageBody());
            this.binding.setMapHttpMessageHeaders(isMapHttpMessageHeaders());
            this.binding.setMapHttpMessageFormUrlEncodedBody(isMapHttpMessageFormUrlEncodedBody());
        }
        return this.binding;
    }

    private void createSetVariableDefinitions(Object[] variableNamesAndExprs) {
        if (variableNamesAndExprs.length == 1 && variableNamesAndExprs[0] instanceof Map) {
            createVariablesFromMap((Map<?, ?>) variableNamesAndExprs[0]);
        } else if (variableNamesAndExprs.length % 2 != 0) {
            throw new IllegalArgumentException("Must be a Map or have an even number of arguments!");
        } else {
            for (int i = 0; i < variableNamesAndExprs.length; i += 2) {
                addVariable(variableNamesAndExprs[i], variableNamesAndExprs[i + 1]);
            }
        }
    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    private void doInsertList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Inserting: {} using statement: {}", in, statement);
            result = session.insert(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Inserting using statement: {}", statement);
            result = session.insert(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public static void doWithFields(Class<?> clazz, FieldCallback fc) throws IllegalArgumentException {
         
        Class<?> targetClass = clazz;
        do {
            Field[] fields = targetClass.getDeclaredFields();
            for (Field field : fields) {
                try {
                    fc.doWith(field);
                } catch (IllegalAccessException ex) {
                    throw new IllegalStateException("Shouldn't be illegal to access field '" + field.getName() + "': " + ex);
                }
            }
            targetClass = targetClass.getSuperclass();
        } while (targetClass != null && targetClass != Object.class);
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
         
        if (!isRunAllowed()) {
            if (exchange.getException() == null) {
                exchange.setException(new RejectedExecutionException());
            }
             
            callback.done(true);
            return true;
        }

        try {
            if (!getEndpoint().isDisableReplyTo() && exchange.getPattern().isOutCapable()) {
                 
                return processInOut(exchange, callback);
            } else {
                 
                return processInOnly(exchange, callback);
            }
        } catch (Exception e) {
             
             
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    private void untagDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        if (ObjectHelper.isEmpty(exchange.getIn().getHeader(DigitalOceanHeaders.NAME))) {
            throw new IllegalArgumentException(DigitalOceanHeaders.NAME + " must be specified");
        }

        ArrayList<Resource> resources = new ArrayList<>(1);
        resources.add(new Resource(dropletId.toString(), ResourceType.DROPLET));
        Response response = getEndpoint().getDigitalOceanClient().untagResources(dropletId.toString(), resources);
        LOG.trace("Untag Droplet {} : [{}] ", dropletId, response);
        exchange.getMessage().setBody(response);
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    public void executeSyncReport(
            String reportId, Boolean includeDetails, ReportMetadata reportMetadata, final Map<String, List<String>> headers,
            final ReportResultsResponseCallback callback) {

        final boolean useGet = reportMetadata == null;
        final Request request
                = getRequest(useGet ? HttpMethod.GET : HttpMethod.POST, reportsUrl(reportId, includeDetails), headers);

         
        if (!useGet) {
            try {
                 
                final HashMap<String, Object> input = new HashMap<>();
                input.put("reportMetadata", reportMetadata);
                marshalRequest(input, request);
            } catch (SalesforceException e) {
                callback.onResponse(null, Collections.emptyMap(), e);
                return;
            }
        }

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                SyncReportResults reportResults = null;
                try {
                    reportResults = unmarshalResponse(response, request, SyncReportResults.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(reportResults, headers, ex);
            }
        });
    }

    private boolean updateMimeTypeHelper(File camelDir, Map<String, String> types) throws Exception {
         
        File java = new File(camelDir, "src/main/java/org/apache/camel/util/MimeTypeHelper.java");
        String text = PackageHelper.loadText(java);
        String spaces4 = "    ";
        String spaces12 = "            ";

        StringJoiner sb = new StringJoiner("\n");
        for (var e : types.entrySet()) {
            sb.add(spaces12 + "case \"" + e.getKey() + "\" -> \"" + e.getValue() + "\";");
        }
        String changed = sb.toString();

        String existing = Strings.between(text, TYPES_START_TOKEN, TYPES_END_TOKEN);
        if (existing != null) {
             
            existing = existing.trim();
            changed = changed.trim();
            if (existing.equals(changed)) {
                return false;
            } else {
                String before = Strings.before(text, TYPES_START_TOKEN);
                String after = Strings.after(text, TYPES_END_TOKEN);
                text = before + TYPES_START_TOKEN + "\n" + spaces12 + changed + "\n" + spaces12 + TYPES_END_TOKEN + after;
                PackageHelper.writeText(java, text);
                return true;
            }
        }

        return false;
    }

    private void analyzeText(Exchange exchange) {
        NaturalLanguageUnderstanding nlu = getEndpoint().getNluClient();
        if (nlu == null) {
            throw new IllegalStateException("NLU client not initialized. Use service=nlu");
        }

        String text = exchange.getIn().getHeader(WatsonLanguageConstants.TEXT, String.class);
        if (text == null) {
            text = exchange.getIn().getBody(String.class);
        }

        if (text == null || text.isBlank()) {
            throw new IllegalArgumentException("Text to analyze must be specified");
        }

        LOG.trace("Analyzing text with NLU");

        Features features = buildFeatures(exchange);

        AnalyzeOptions options = new AnalyzeOptions.Builder()
                .text(text)
                .features(features)
                .build();

        AnalysisResults result = nlu.analyze(options).execute().getResult();

        Message message = getMessageForResponse(exchange);

         
        message.setBody(result);

         
        if (result.getSentiment() != null && result.getSentiment().getDocument() != null) {
            message.setHeader(WatsonLanguageConstants.SENTIMENT_SCORE, result.getSentiment().getDocument().getScore());
            message.setHeader(WatsonLanguageConstants.SENTIMENT_LABEL, result.getSentiment().getDocument().getLabel());
        }
        if (result.getLanguage() != null) {
            message.setHeader(WatsonLanguageConstants.LANGUAGE, result.getLanguage());
        }
    }

    public Integer extractTokenCount(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode response = node.get("response");
        if (response != null) {
            JsonNode meta = response.get("meta");
            if (meta != null) {
                JsonNode tokens = meta.get("tokens");
                if (tokens != null) {
                    JsonNode outputTokens = tokens.get("output_tokens");
                    return outputTokens != null && !outputTokens.isNull() ? outputTokens.asInt() : null;
                }
            }
        }
        return null;
    }

        public void onTopic(String channel, IRCUser user, String topic) {
            if (configuration.isOnTopic()) {
                Exchange exchange = createOnTopicExchange(channel, user, topic);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    public ResequenceDefinition reverse() {
        if (streamConfig != null) {
            throw new IllegalStateException("reverse() only supported for batch resequencer");
        }
         
        if (batchConfig == null) {
            batch();
        }
        batchConfig.setReverse(Boolean.toString(true));
        return this;
    }

    public <K, V> BasicCache<K, V> getCache(String cacheName) {
        Cache<K, V> cache;
        if (ObjectHelper.isEmpty(cacheName) || CACHE_MANAGER_CURRENT.equals(cacheName)) {
            cache = cacheContainer.getCache();
        } else {
            cache = cacheContainer.getCache(cacheName);
        }

        return configuration.hasFlags()
                ? cache.getAdvancedCache().withFlags(configuration.getFlags())
                : cache;
    }

        public void run() {
            FilterWatchListDeletable<Deployment, DeploymentList, RollableScalableResource<Deployment>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().apps().deployments().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<Deployment, DeploymentList, RollableScalableResource<Deployment>> client
                        = getEndpoint().getKubernetesClient().apps().deployments().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<Deployment, DeploymentList, RollableScalableResource<Deployment>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, Deployment resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Failover).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    protected String getHttpUrl(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    private void addMainListenerClass(Class<? extends MainListener>... listener) {
        StringJoiner existing = new StringJoiner(",");
        if (mainListenerClasses != null && !mainListenerClasses.isEmpty()) {
            existing.add(mainListenerClasses);
        }
        if (listener != null) {
            for (Class<? extends MainListener> clazz : listener) {
                existing.add(clazz.getName());
            }
        }
        setMainListenerClasses(existing.toString());
    }

    protected AbstractGitHubProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);
        this.endpoint = endpoint;

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_REPOSITORY_SERVICE);
        if (service != null) {
            repositoryService = (RepositoryService) service;
        } else {
            repositoryService = new RepositoryService();
        }
        initService(repositoryService);
        repository = repositoryService.getRepository(endpoint.getRepoOwner(), endpoint.getRepoName());
    }

    public static String nodeValue(final int namespace, final ByteString node) {
        Objects.requireNonNull(namespace);
        Objects.requireNonNull(node);

        final StringBuilder builder = new StringBuilder("RAW(");
        appendNamespace(builder, namespace);
        builder.append(';');
        appendNodeId(builder, node);
        builder.append(')');
        return builder.toString();
    }

    public HttpBinding getHttpBinding() {
         
        if (this.binding == null) {
            this.binding = new AttachmentHttpBinding();
            this.binding.setTransferException(isTransferException());
            this.binding.setMuteException(isMuteException());
            this.binding.setLogException(isLogException());
            if (getComponent() != null) {
                this.binding.setAllowJavaSerializedObject(getComponent().isAllowJavaSerializedObject());
            }
            this.binding.setHeaderFilterStrategy(getHeaderFilterStrategy());
            this.binding.setEagerCheckContentAvailable(isEagerCheckContentAvailable());
            this.binding.setMapHttpMessageBody(isMapHttpMessageBody());
            this.binding.setMapHttpMessageHeaders(isMapHttpMessageHeaders());
            this.binding.setMapHttpMessageFormUrlEncodedBody(isMapHttpMessageFormUrlEncodedBody());
        }
        return this.binding;
    }

    private void configureFifoAttributes(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        if (getEndpoint().getConfiguration().isFifoQueue()) {
             
            MessageGroupIdStrategy messageGroupIdStrategy = getEndpoint().getConfiguration().getMessageGroupIdStrategy();
            String messageGroupId = messageGroupIdStrategy.getMessageGroupId(exchange);
            request.messageGroupId(messageGroupId);

            MessageDeduplicationIdStrategy messageDeduplicationIdStrategy
                    = getEndpoint().getConfiguration().getMessageDeduplicationIdStrategy();
            String messageDeduplicationId = messageDeduplicationIdStrategy.getMessageDeduplicationId(exchange);
            request.messageDeduplicationId(messageDeduplicationId);

        }
    }

                public void artifactDownloading(RepositoryEvent event) {
                    watch.restart();

                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloading(a.getGroupId(), a.getArtifactId(), version,
                                id, url);
                    }
                }

    public static InvokeModelWithResponseStreamResponseHandler createChunksHandler(
            String modelId,
            StreamMetadata metadata,
            List<String> chunks,
            Consumer<String> chunkConsumer) {

        StreamResponseParser parser = StreamParserFactory.getParser(modelId);
        int[] chunkCount = { 0 };

        return InvokeModelWithResponseStreamResponseHandler.builder()
                .subscriber(InvokeModelWithResponseStreamResponseHandler.Visitor.builder()
                        .onChunk(part -> {
                            try {
                                String chunkJson = part.bytes().asUtf8String();
                                String text = parser.extractText(chunkJson);

                                if (text != null && !text.isEmpty()) {
                                    chunks.add(text);
                                    if (chunkConsumer != null) {
                                        chunkConsumer.accept(text);
                                    }
                                }

                                 
                                if (parser.isFinalChunk(chunkJson)) {
                                    String completionReason = parser.extractCompletionReason(chunkJson);
                                    if (completionReason != null) {
                                        metadata.setCompletionReason(completionReason);
                                    }

                                    Integer tokenCount = parser.extractTokenCount(chunkJson);
                                    if (tokenCount != null) {
                                        metadata.setTokenCount(tokenCount);
                                    }
                                }
                                chunkCount[0]++;
                            } catch (JsonProcessingException e) {
                                LOG.warn("Error parsing streaming chunk: {}", e.getMessage(), e);
                            }
                        })
                        .build())
                .onComplete(() -> {
                    metadata.setChunkCount(chunkCount[0]);
                    metadata.setChunks(chunks);
                })
                .build();
    }

    protected void doStart() throws Exception {
        super.doStart();
        try {
            plc4XEndpoint.setupConnection();
        } catch (PlcConnectionException e) {
            if (LOGGER.isTraceEnabled()) {
                LOGGER.error("Connection setup failed, stopping PollingConsumer", e);
            } else {
                LOGGER.error("Connection setup failed, stopping PollingConsumer");
            }
            doStop();
        }
    }

    public CompletableFuture<Void> compensate(Exchange exchange) {
        boolean doAction = currentStatus.compareAndSet(Status.RUNNING, Status.COMPENSATING);

        if (doAction) {
            doCompensate(exchange);
        } else {
            Status status = currentStatus.get();
            if (status != Status.COMPENSATING && status != Status.COMPENSATED) {
                CompletableFuture<Void> res = new CompletableFuture<>();
                res.completeExceptionally(new IllegalStateException("Cannot compensate: status is " + status));
                return res;
            }
        }

        return CompletableFuture.completedFuture(null);
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.sheets.stream.consume");

        if (message.getHeaders().containsKey(GoogleSheetsStreamConstants.SPREADSHEET_ID)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.sheets.stream." + message.getHeader(GoogleSheetsStreamConstants.SPREADSHEET_ID, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(GoogleSheetsStreamConstants.SPREADSHEET_URL));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public void getRecentReports(final Map<String, List<String>> headers, final RecentReportsResponseCallback callback) {
        final Request request = getRequest(HttpMethod.GET, reportsUrl(), headers);

        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }
        });
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator == null) {
                exchange.setException(new CamelExchangeException("Exchange is not part of a saga", exchange));
                callback.done(false);
            } else {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            }
        }));
        return false;
    }

    public void index(Object result) {
        if (result instanceof ClientEntitySet) {
            index((ClientEntitySet) result);
        } else if (result instanceof Iterable) {
            index((Iterable<?>) result);
        } else {
            indexDefault(result);
        }
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    private void setupDevConsoleRegistry() {
        DevConsoleRegistry devConsoleRegistry = getBeanForType(DevConsoleRegistry.class);
        if (devConsoleRegistry != null) {
            devConsoleRegistry.setCamelContext(getContext());
            LOG.debug("Using DevConsoleRegistry: {}", devConsoleRegistry);
            getContext().getCamelContextExtension().addContextPlugin(DevConsoleRegistry.class, devConsoleRegistry);
        } else {
             
            devConsoleRegistry = DevConsoleRegistry.get(getContext());
            if (devConsoleRegistry != null) {
                devConsoleRegistry.setCamelContext(getContext());
            }
        }
        if (devConsoleRegistry != null) {
            Set<DevConsole> consoles = getContext().getRegistry().findByType(DevConsole.class);
            for (DevConsole console : consoles) {
                devConsoleRegistry.register(console);
            }
        }
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        AtomicBoolean remoteVisible = new AtomicBoolean();
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("inflight");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("exchanges");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.exchangeId = jo.getString("exchangeId");
                                    row.fromRouteId = jo.getString("fromRouteId");
                                    Boolean bool = jo.getBoolean("fromRemoteEndpoint");
                                    if (bool != null) {
                                         
                                        remoteVisible.set(true);
                                        row.fromRemoteEndpoint = bool;
                                    }
                                    row.atRouteId = jo.getString("atRouteId");
                                    row.nodeId = jo.getString("nodeId");
                                    row.elapsed = jo.getLong("elapsed");
                                    row.duration = jo.getLong("duration");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("EXCHANGE-ID").dataAlign(HorizontalAlign.LEFT).with(r -> r.exchangeId),
                    new Column().header("REMOTE").visible(remoteVisible.get()).dataAlign(HorizontalAlign.CENTER)
                            .with(this::getRemote),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.atRouteId),
                    new Column().header("ID").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.nodeId),
                    new Column().header("ELAPSED").dataAlign(HorizontalAlign.RIGHT).with(this::getElapsed),
                    new Column().header("DURATION").dataAlign(HorizontalAlign.RIGHT).with(this::getDuration))));
        }

        return 0;
    }

    public static Object deserializeJavaObjectFromStream(InputStream is, CamelContext context)
            throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer;
        ObjectInputStream ois = new CamelObjectInputStream(is, context);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    private Expression createAndExpression(final Expression leftExp, final Expression rightExp) {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                Predicate predicate = ExpressionToPredicateAdapter.toPredicate(leftExp);
                predicate = PredicateBuilder.and(predicate, ExpressionToPredicateAdapter.toPredicate(rightExp));

                boolean answer = predicate.matches(exchange);
                return exchange.getContext().getTypeConverter().convertTo(type, answer);
            }

            @Override
            public String toString() {
                return left + " " + token.getText() + " " + right;
            }
        };
    }

    private void createMavenPom(Path settings, Path pom, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        InputStream is = ExportQuarkus.class.getClassLoader().getResourceAsStream("templates/" + pomTemplateName);
        String context = IOHelper.loadText(is);
        IOHelper.close(is);

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
         
        String repos = getMavenRepositories(settings, prop, quarkusVersion);

        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(repos, quarkusVersion, quarkusGroupId, download);
        if (camelVersion == null) {
            camelVersion = catalog.getCatalogVersion();
        }

        String mp = prop.getProperty("quarkus.management.port");
        if (mp == null) {
            mp = "9876";
        }

        context = context.replaceAll("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceAll("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceAll("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.QuarkusGroupId }}", quarkusGroupId);
        context = context.replaceAll("\\{\\{ \\.QuarkusArtifactId }}", quarkusArtifactId);
        context = context.replaceAll("\\{\\{ \\.QuarkusVersion }}", quarkusVersion);
        context = context.replaceAll("\\{\\{ \\.QuarkusManagementPort }}", mp);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceAll("\\{\\{ \\.ProjectBuildOutputTimestamp }}", this.getBuildMavenProjectDate());

        context = replaceBuildProperties(context);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            String s = mavenRepositoriesAsPomXml(repos);
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", s);
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();
             
            if ("org.apache.camel".equals(gid)) {
                String qaid = aid.replace("camel-", "camel-quarkus-");
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.quarkus", qaid, null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        replaceQuarkusDependencies(gavs);

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
             
            if ("camel-quarkus-core".equals(gav.getArtifactId())
                    || "camel-quarkus-microprofile-health".equals(gav.getArtifactId())) {
                continue;
            }
            sb.append("        <dependency>\n");
            sb.append("            <groupId>").append(gav.getGroupId()).append("</groupId>\n");
            sb.append("            <artifactId>").append(gav.getArtifactId()).append("</artifactId>\n");
            if (gav.getVersion() != null) {
                sb.append("            <version>").append(gav.getVersion()).append("</version>\n");
            }
            if (gav.getScope() != null) {
                sb.append("            <scope>").append(gav.getScope()).append("</scope>\n");
            }
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("            <scope>system</scope>\n");
                sb.append("            <systemPath>\\$\\{project.basedir}/lib/").append(gav.getArtifactId()).append("-")
                        .append(gav.getVersion()).append(".jar</systemPath>\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("            <exclusions>\n");
                sb.append("                <exclusion>\n");
                sb.append("                    <groupId>org.apache.camel</groupId>\n");
                sb.append("                    <artifactId>*</artifactId>\n");
                sb.append("                </exclusion>\n");
                sb.append("            </exclusions>\n");
            }
            sb.append("        </dependency>\n");
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        Files.writeString(pom, context);
    }

    public BlacklistServiceCallServiceFilterConfiguration servers(String servers) {
        if (ObjectHelper.isNotEmpty(servers)) {
            String[] parts = servers.split(",");

            if (this.servers == null) {
                this.servers = new ArrayList<>();
            }

            this.servers.addAll(Arrays.asList(parts));
        }

        return this;
    }

    public GenericFileProcessStrategy<ShareFileItem> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<ShareFileItem> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<ShareFileItem> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<ShareFileItem> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<ShareFileItem> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<ShareFileItem> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<ShareFileItem> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<ShareFileItem> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<ShareFileItem> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    protected void doListPersistentVolumesClaimsByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUMES_CLAIMS_LABELS, Map.class);
        PersistentVolumeClaimList pvcList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing PersistentVolumeClaims by labels requires specifying labels");
            throw new IllegalArgumentException("Listing PersistentVolumeClaims by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inAnyNamespace().withLabels(labels).list();
        } else {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespace).withLabels(labels)
                    .list();
        }

        prepareOutboundMessage(exchange, pvcList.getItems());
    }

    public void marshal(final Exchange exchange, final Object graph, final OutputStream stream) throws Exception {
        String filename;
        String filepath = exchange.getIn().getHeader(FILE_NAME, String.class);
        Long filelength = exchange.getIn().getHeader(FILE_LENGTH, Long.class);
        if (filepath == null) {
             
            filename = filepath = StringHelper.sanitize(exchange.getIn().getMessageId());
        } else {
            filename = Paths.get(filepath).getFileName().toString();  
        }

        TarArchiveOutputStream tos = new TarArchiveOutputStream(stream);
        tos.setLongFileMode(TarArchiveOutputStream.LONGFILE_POSIX);
        tos.setBigNumberMode(TarArchiveOutputStream.BIGNUMBER_POSIX);

        InputStream is = exchange.getContext().getTypeConverter().mandatoryConvertTo(InputStream.class, graph);
        if (filelength == null) {
            filelength = (long) is.available();
        }

        if (preservePathElements) {
            createTarEntries(tos, filepath, filelength);
        } else {
            createTarEntries(tos, filename, filelength);
        }

        try {
            IOHelper.copy(is, tos);
        } finally {
            tos.closeArchiveEntry();
            IOHelper.close(is, tos);
        }

        String newFilename = filename + ".tar";
        exchange.getMessage().setHeader(FILE_NAME, newFilename);
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((KafkaComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "brokers": getOrCreateConfiguration((KafkaComponent) component).setBrokers((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((KafkaComponent) component).setClientId((java.lang.String) value); return true;
            case "configuration": ((KafkaComponent) component).setConfiguration((org.apache.camel.component.kafka.KafkaConfiguration) value); return true;
            case "headerFilterStrategy": getOrCreateConfiguration((KafkaComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "reconnectBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMs((java.lang.Integer) value); return true;
            case "shutdownTimeout": getOrCreateConfiguration((KafkaComponent) component).setShutdownTimeout((int) value); return true;
            case "allowManualCommit": getOrCreateConfiguration((KafkaComponent) component).setAllowManualCommit((boolean) value); return true;
            case "autoCommitEnable": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitEnable((boolean) value); return true;
            case "autoCommitIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitIntervalMs((java.lang.Integer) value); return true;
            case "autoOffsetReset": getOrCreateConfiguration((KafkaComponent) component).setAutoOffsetReset((java.lang.String) value); return true;
            case "batching": getOrCreateConfiguration((KafkaComponent) component).setBatching((boolean) value); return true;
            case "batchingIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setBatchingIntervalMs((java.lang.Integer) value); return true;
            case "breakOnFirstError": getOrCreateConfiguration((KafkaComponent) component).setBreakOnFirstError((boolean) value); return true;
            case "bridgeErrorHandler": ((KafkaComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "checkCrcs": getOrCreateConfiguration((KafkaComponent) component).setCheckCrcs((java.lang.Boolean) value); return true;
            case "commitTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setCommitTimeoutMs((java.lang.Long) value); return true;
            case "consumerRequestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setConsumerRequestTimeoutMs((java.lang.Integer) value); return true;
            case "consumersCount": getOrCreateConfiguration((KafkaComponent) component).setConsumersCount((int) value); return true;
            case "fetchMaxBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMaxBytes((java.lang.Integer) value); return true;
            case "fetchMinBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMinBytes((java.lang.Integer) value); return true;
            case "fetchWaitMaxMs": getOrCreateConfiguration((KafkaComponent) component).setFetchWaitMaxMs((java.lang.Integer) value); return true;
            case "groupId": getOrCreateConfiguration((KafkaComponent) component).setGroupId((java.lang.String) value); return true;
            case "groupInstanceId": getOrCreateConfiguration((KafkaComponent) component).setGroupInstanceId((java.lang.String) value); return true;
            case "headerDeserializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderDeserializer((org.apache.camel.component.kafka.serde.KafkaHeaderDeserializer) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setHeartbeatIntervalMs((java.lang.Integer) value); return true;
            case "keyDeserializer": getOrCreateConfiguration((KafkaComponent) component).setKeyDeserializer((java.lang.String) value); return true;
            case "maxPartitionFetchBytes": getOrCreateConfiguration((KafkaComponent) component).setMaxPartitionFetchBytes((java.lang.Integer) value); return true;
            case "maxPollIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setMaxPollIntervalMs((java.lang.Integer) value); return true;
            case "maxPollRecords": getOrCreateConfiguration((KafkaComponent) component).setMaxPollRecords((java.lang.Integer) value); return true;
            case "offsetRepository": getOrCreateConfiguration((KafkaComponent) component).setOffsetRepository((org.apache.camel.spi.StateRepository) value); return true;
            case "partitionAssignor": getOrCreateConfiguration((KafkaComponent) component).setPartitionAssignor((java.lang.String) value); return true;
            case "pollOnError": getOrCreateConfiguration((KafkaComponent) component).setPollOnError((org.apache.camel.component.kafka.PollOnError) value); return true;
            case "pollTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setPollTimeoutMs((java.lang.Long) value); return true;
            case "preValidateHostAndPort": getOrCreateConfiguration((KafkaComponent) component).setPreValidateHostAndPort((boolean) value); return true;
            case "seekTo": getOrCreateConfiguration((KafkaComponent) component).setSeekTo((org.apache.camel.component.kafka.SeekPolicy) value); return true;
            case "sessionTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setSessionTimeoutMs((java.lang.Integer) value); return true;
            case "specificAvroReader": getOrCreateConfiguration((KafkaComponent) component).setSpecificAvroReader((boolean) value); return true;
            case "topicIsPattern": getOrCreateConfiguration((KafkaComponent) component).setTopicIsPattern((boolean) value); return true;
            case "valueDeserializer": getOrCreateConfiguration((KafkaComponent) component).setValueDeserializer((java.lang.String) value); return true;
            case "createConsumerBackoffInterval": ((KafkaComponent) component).setCreateConsumerBackoffInterval((long) value); return true;
            case "createConsumerBackoffMaxAttempts": ((KafkaComponent) component).setCreateConsumerBackoffMaxAttempts((int) value); return true;
            case "isolationLevel": getOrCreateConfiguration((KafkaComponent) component).setIsolationLevel((java.lang.String) value); return true;
            case "kafkaManualCommitFactory": ((KafkaComponent) component).setKafkaManualCommitFactory((org.apache.camel.component.kafka.consumer.KafkaManualCommitFactory) value); return true;
            case "pollExceptionStrategy": ((KafkaComponent) component).setPollExceptionStrategy((org.apache.camel.component.kafka.PollExceptionStrategy) value); return true;
            case "subscribeConsumerBackoffInterval": ((KafkaComponent) component).setSubscribeConsumerBackoffInterval((long) value); return true;
            case "subscribeConsumerBackoffMaxAttempts": ((KafkaComponent) component).setSubscribeConsumerBackoffMaxAttempts((int) value); return true;
            case "subscribeConsumerTopicMustExists": ((KafkaComponent) component).setSubscribeConsumerTopicMustExists((boolean) value); return true;
            case "batchWithIndividualHeaders": getOrCreateConfiguration((KafkaComponent) component).setBatchWithIndividualHeaders((boolean) value); return true;
            case "bufferMemorySize": getOrCreateConfiguration((KafkaComponent) component).setBufferMemorySize((java.lang.Integer) value); return true;
            case "compressionCodec": getOrCreateConfiguration((KafkaComponent) component).setCompressionCodec((java.lang.String) value); return true;
            case "connectionMaxIdleMs": getOrCreateConfiguration((KafkaComponent) component).setConnectionMaxIdleMs((java.lang.Integer) value); return true;
            case "deliveryTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setDeliveryTimeoutMs((java.lang.Integer) value); return true;
            case "enableIdempotence": getOrCreateConfiguration((KafkaComponent) component).setEnableIdempotence((boolean) value); return true;
            case "headerSerializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderSerializer((org.apache.camel.component.kafka.serde.KafkaHeaderSerializer) value); return true;
            case "key": getOrCreateConfiguration((KafkaComponent) component).setKey((java.lang.String) value); return true;
            case "keySerializer": getOrCreateConfiguration((KafkaComponent) component).setKeySerializer((java.lang.String) value); return true;
            case "lazyStartProducer": ((KafkaComponent) component).setLazyStartProducer((boolean) value); return true;
            case "lingerMs": getOrCreateConfiguration((KafkaComponent) component).setLingerMs((java.lang.Integer) value); return true;
            case "maxBlockMs": getOrCreateConfiguration((KafkaComponent) component).setMaxBlockMs((java.lang.Integer) value); return true;
            case "maxInFlightRequest": getOrCreateConfiguration((KafkaComponent) component).setMaxInFlightRequest((java.lang.Integer) value); return true;
            case "maxRequestSize": getOrCreateConfiguration((KafkaComponent) component).setMaxRequestSize((java.lang.Integer) value); return true;
            case "metadataMaxAgeMs": getOrCreateConfiguration((KafkaComponent) component).setMetadataMaxAgeMs((java.lang.Integer) value); return true;
            case "metricReporters": getOrCreateConfiguration((KafkaComponent) component).setMetricReporters((java.lang.String) value); return true;
            case "metricsSampleWindowMs": getOrCreateConfiguration((KafkaComponent) component).setMetricsSampleWindowMs((java.lang.Integer) value); return true;
            case "noOfMetricsSample": getOrCreateConfiguration((KafkaComponent) component).setNoOfMetricsSample((java.lang.Integer) value); return true;
            case "partitioner": getOrCreateConfiguration((KafkaComponent) component).setPartitioner((java.lang.String) value); return true;
            case "partitionerIgnoreKeys": getOrCreateConfiguration((KafkaComponent) component).setPartitionerIgnoreKeys((boolean) value); return true;
            case "partitionKey": getOrCreateConfiguration((KafkaComponent) component).setPartitionKey((java.lang.Integer) value); return true;
            case "producerBatchSize": getOrCreateConfiguration((KafkaComponent) component).setProducerBatchSize((java.lang.Integer) value); return true;
            case "queueBufferingMaxMessages": getOrCreateConfiguration((KafkaComponent) component).setQueueBufferingMaxMessages((java.lang.Integer) value); return true;
            case "receiveBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setReceiveBufferBytes((java.lang.Integer) value); return true;
            case "reconnectBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMs((java.lang.Integer) value); return true;
            case "requestRequiredAcks": getOrCreateConfiguration((KafkaComponent) component).setRequestRequiredAcks((java.lang.String) value); return true;
            case "requestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setRequestTimeoutMs((java.lang.Integer) value); return true;
            case "retries": getOrCreateConfiguration((KafkaComponent) component).setRetries((java.lang.Integer) value); return true;
            case "sendBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setSendBufferBytes((java.lang.Integer) value); return true;
            case "transacted": getOrCreateConfiguration((KafkaComponent) component).setTransacted((boolean) value); return true;
            case "transactionalId": getOrCreateConfiguration((KafkaComponent) component).setTransactionalId((java.lang.String) value); return true;
            case "useIterator": getOrCreateConfiguration((KafkaComponent) component).setUseIterator((boolean) value); return true;
            case "valueSerializer": getOrCreateConfiguration((KafkaComponent) component).setValueSerializer((java.lang.String) value); return true;
            case "workerPool": getOrCreateConfiguration((KafkaComponent) component).setWorkerPool((java.util.concurrent.ExecutorService) value); return true;
            case "workerPoolCoreSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolCoreSize((java.lang.Integer) value); return true;
            case "workerPoolMaxSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolMaxSize((java.lang.Integer) value); return true;
            case "recordMetadata": getOrCreateConfiguration((KafkaComponent) component).setRecordMetadata((boolean) value); return true;
            case "autowiredEnabled": ((KafkaComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "kafkaClientFactory": ((KafkaComponent) component).setKafkaClientFactory((org.apache.camel.component.kafka.KafkaClientFactory) value); return true;
            case "synchronous": getOrCreateConfiguration((KafkaComponent) component).setSynchronous((boolean) value); return true;
            case "healthCheckConsumerEnabled": ((KafkaComponent) component).setHealthCheckConsumerEnabled((boolean) value); return true;
            case "healthCheckProducerEnabled": ((KafkaComponent) component).setHealthCheckProducerEnabled((boolean) value); return true;
            case "interceptorClasses": getOrCreateConfiguration((KafkaComponent) component).setInterceptorClasses((java.lang.String) value); return true;
            case "schemaRegistryURL": getOrCreateConfiguration((KafkaComponent) component).setSchemaRegistryURL((java.lang.String) value); return true;
            case "kerberosBeforeReloginMinTime": getOrCreateConfiguration((KafkaComponent) component).setKerberosBeforeReloginMinTime((java.lang.Integer) value); return true;
            case "kerberosConfigLocation": getOrCreateConfiguration((KafkaComponent) component).setKerberosConfigLocation((java.lang.String) value); return true;
            case "kerberosInitCmd": getOrCreateConfiguration((KafkaComponent) component).setKerberosInitCmd((java.lang.String) value); return true;
            case "kerberosPrincipalToLocalRules": getOrCreateConfiguration((KafkaComponent) component).setKerberosPrincipalToLocalRules((java.lang.String) value); return true;
            case "kerberosRenewJitter": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewJitter((java.lang.Double) value); return true;
            case "kerberosRenewWindowFactor": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewWindowFactor((java.lang.Double) value); return true;
            case "saslJaasConfig": getOrCreateConfiguration((KafkaComponent) component).setSaslJaasConfig((java.lang.String) value); return true;
            case "saslKerberosServiceName": getOrCreateConfiguration((KafkaComponent) component).setSaslKerberosServiceName((java.lang.String) value); return true;
            case "saslMechanism": getOrCreateConfiguration((KafkaComponent) component).setSaslMechanism((java.lang.String) value); return true;
            case "securityProtocol": getOrCreateConfiguration((KafkaComponent) component).setSecurityProtocol((java.lang.String) value); return true;
            case "sslCipherSuites": getOrCreateConfiguration((KafkaComponent) component).setSslCipherSuites((java.lang.String) value); return true;
            case "sslContextParameters": getOrCreateConfiguration((KafkaComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "sslEnabledProtocols": getOrCreateConfiguration((KafkaComponent) component).setSslEnabledProtocols((java.lang.String) value); return true;
            case "sslEndpointAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslEndpointAlgorithm((java.lang.String) value); return true;
            case "sslKeymanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslKeymanagerAlgorithm((java.lang.String) value); return true;
            case "sslKeyPassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeyPassword((java.lang.String) value); return true;
            case "sslKeystoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreLocation((java.lang.String) value); return true;
            case "sslKeystorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeystorePassword((java.lang.String) value); return true;
            case "sslKeystoreType": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreType((java.lang.String) value); return true;
            case "sslProtocol": getOrCreateConfiguration((KafkaComponent) component).setSslProtocol((java.lang.String) value); return true;
            case "sslProvider": getOrCreateConfiguration((KafkaComponent) component).setSslProvider((java.lang.String) value); return true;
            case "sslTrustmanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslTrustmanagerAlgorithm((java.lang.String) value); return true;
            case "sslTruststoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreLocation((java.lang.String) value); return true;
            case "sslTruststorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslTruststorePassword((java.lang.String) value); return true;
            case "sslTruststoreType": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreType((java.lang.String) value); return true;
            case "useGlobalSslContextParameters": ((KafkaComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            default: return false;
            }
        }

    public InputStream getResourceAsStream(String name) {
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(name);
        }
        if (is == null) {
            is = DefaultCamelCatalog.class.getClassLoader().getResourceAsStream(name);
        }
        return is;
    }

    public <T extends Enum<T>> T getEnumOrDefault(final String key, final T defaultValue) throws ClassNotFoundException {
         
        T returnable;
        final String value;
        final String[] splitValues;
        final int numberOfSplitValues;
        final StringBuilder returnTypeName;
        final StringBuilder enumName;
        final Class<T> returnType;
         
        if (this.containsKey(key)) {
             
            value = this.getStringOrDefault(key, "");
            if (value == null) {
                return null;
            }
             
            splitValues = value.split("\\.");
            numberOfSplitValues = splitValues.length;
            returnTypeName = new StringBuilder();
            enumName = new StringBuilder();
            for (int i = 0; i < numberOfSplitValues; i++) {
                if (i == (numberOfSplitValues - 1)) {
                     
                    enumName.append(splitValues[i]);
                } else if (i == (numberOfSplitValues - 2)) {
                     
                    returnTypeName.append(splitValues[i]);
                } else {
                     
                    returnTypeName.append(splitValues[i]);
                    returnTypeName.append(".");
                }
            }
             
            returnType = (Class<T>) Class.forName(returnTypeName.toString());
            returnable = Enum.valueOf(returnType, enumName.toString());
        } else {
             
            return defaultValue;
        }
        return returnable;
    }

    public Publisher<Exchange> to(String uri, Object data) {
        requestedUriToStream.computeIfAbsent(uri, u -> {
            try {
                String uuid = context.getUuidGenerator().generateUuid();
                new RouteBuilder() {
                    @Override
                    public void configure() {
                        from("reactive-streams:" + uuid)
                                .to(u);
                    }
                }.addRoutesToCamelContext(context);

                return uuid;
            } catch (Exception e) {
                throw new IllegalStateException("Unable to create requested reactive stream from direct URI: " + uri, e);
            }
        });
        return toStream(requestedUriToStream.get(uri), data);
    }

    private void addDelay(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        Integer headerValue = exchange.getIn().getHeader(Sqs2Constants.DELAY_HEADER, Integer.class);
        Integer delayValue;
        if (headerValue == null) {
            LOG.trace("Using the config delay");
            delayValue = getEndpoint().getConfiguration().getDelaySeconds();
        } else {
            LOG.trace("Using the header delay");
            delayValue = headerValue;
        }
        LOG.trace("found delay: {}", delayValue);
        if (delayValue != null) {
            request.delaySeconds(delayValue);
        }
    }

    public void getRequest(
            String jobId, String batchId, Map<String, List<String>> headers, final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchRequestUrl(jobId, batchId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private static Map<String, Object> checkValidHeaderObjects(
            String type, Exchange exchange, Map<String, Object> map, boolean allowSerializedHeaders) {
        if (map == null) {
            return null;
        }

        Map<String, Object> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {

             
            if (entry.getValue() == null) {
                continue;
            }

            Object value = getValidHeaderValue(entry.getKey(), entry.getValue(), allowSerializedHeaders);
            if (value != null) {
                Serializable converted
                        = exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, value);
                if (converted != null) {
                    result.put(entry.getKey(), converted);
                } else {
                    logCannotSerializeObject(type, entry.getKey(), entry.getValue());
                }
            } else {
                logInvalidHeaderValue(type, entry.getKey(), entry.getValue());
            }
        }

        return result;
    }

    public void close() throws IOException {
        Subscription subscription;
        lock.lock();
        try {
            subscription = this.subscription;
        } finally {
            lock.unlock();
        }

        if (subscription != null) {
            subscription.cancel();
        }
    }

    public Processor createProcessor() throws Exception {
        String key = parseString(definition.getName());
        Expression nameExpr;
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        String toKey = parseString(definition.getToName());
        Expression toNameExpr = null;
        if (toKey != null) {
            if (LanguageSupport.hasSimpleFunction(toKey)) {
                toNameExpr = camelContext.resolveLanguage("simple").createExpression(toKey);
            } else {
                toNameExpr = camelContext.resolveLanguage("constant").createExpression(toKey);
            }
            toNameExpr.init(camelContext);
        }

        Class<?> typeClass = parse(Class.class, or(definition.getTypeClass(), parseString(definition.getType())));
        String charset = validateCharset(parseString(definition.getCharset()));
        boolean mandatory = true;
        if (definition.getMandatory() != null) {
            mandatory = parseBoolean(definition.getMandatory(), true);
        }
        ConvertHeaderProcessor answer
                = new ConvertHeaderProcessor(key, nameExpr, toKey, toNameExpr, typeClass, charset, mandatory);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

        long expectedValue = 0L;

        if (headers.containsKey(HazelcastConstants.EXPECTED_VALUE)) {
            expectedValue = (long) headers.get(HazelcastConstants.EXPECTED_VALUE);
        }

        HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {

            case INCREMENT:
                this.increment(exchange);
                break;

            case DECREMENT:
                this.decrement(exchange);
                break;

            case COMPARE_AND_SET:
                this.compare(expectedValue, exchange);
                break;

            case GET_AND_ADD:
                this.getAndAdd(exchange);
                break;

            case SET_VALUE:
                this.set(exchange);
                break;

            case GET:
                this.get(exchange);
                break;

            case DESTROY:
                this.destroy();
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the ATOMICNUMBER.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    private Domain messageToDomain(Message message) {
        Domain domain = message.getBody(Domain.class);
        if (domain == null) {
            Map<String, Object> headers = message.getHeaders();
            DomainBuilder builder = Builders.domain();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            domain = builder.build();
        }

        return domain;
    }

    private static boolean isCompositeSObjectCollectionsOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE_CREATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPDATE_SOBJECT_COLLECTIONS:
            case COMPOSITE_UPSERT_SOBJECT_COLLECTIONS:
            case COMPOSITE_RETRIEVE_SOBJECT_COLLECTIONS:
            case COMPOSITE_DELETE_SOBJECT_COLLECTIONS:
                return true;
            default:
                return false;
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

        String value = IOHelper.lookupEnvironmentVariable(key);
        return value != null ? value : defaultValue;
    }

    private Olingo4AppWrapper createOlingo4App(Olingo4Configuration configuration) {

        Object clientBuilder = configuration.getHttpAsyncClientBuilder();
        if (clientBuilder == null) {
            HttpAsyncClientBuilder asyncClientBuilder = HttpAsyncClientBuilder.create();

             
            final RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
            requestConfigBuilder.setConnectTimeout(configuration.getConnectTimeout());
            requestConfigBuilder.setSocketTimeout(configuration.getSocketTimeout());

            final HttpHost proxy = configuration.getProxy();
            if (proxy != null) {
                requestConfigBuilder.setProxy(proxy);
            }

             
            asyncClientBuilder.setDefaultRequestConfig(requestConfigBuilder.build());

            SSLContextParameters sslContextParameters = configuration.getSslContextParameters();
            if (sslContextParameters == null) {
                 
                sslContextParameters = retrieveGlobalSslContextParameters();
            }
            if (sslContextParameters == null) {
                 
                sslContextParameters = new SSLContextParameters();
            }
            try {
                asyncClientBuilder.setSSLContext(sslContextParameters.createSSLContext(getCamelContext()));
            } catch (IOException | GeneralSecurityException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }

            clientBuilder = asyncClientBuilder;
        }

        Olingo4AppImpl olingo4App;
        if (clientBuilder == null || clientBuilder instanceof HttpAsyncClientBuilder) {
            olingo4App = new Olingo4AppImpl(configuration.getServiceUri(), (HttpAsyncClientBuilder) clientBuilder);
        } else {
            olingo4App = new Olingo4AppImpl(configuration.getServiceUri(), (HttpClientBuilder) clientBuilder);
        }
        apiProxy = new Olingo4AppWrapper(olingo4App);
        apiProxy.getOlingo4App().setContentType(configuration.getContentType());
        apiProxy.getOlingo4App().setHttpHeaders(configuration.getHttpHeaders());

        return apiProxy;
    }

    protected void doShowTags(Exchange exchange, String operation) throws GitAPIException {
        List<Ref> result = null;
        try {
            result = git.tagList().call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    private String getPrompt(Exchange exchange) {
        String prompt = exchange.getIn().getHeader(GoogleVertexAIConstants.PROMPT, String.class);
        if (prompt == null) {
            prompt = exchange.getIn().getBody(String.class);
        }
        if (prompt == null) {
            throw new IllegalArgumentException("Prompt must be provided in body or header");
        }
        return prompt;
    }

    public MilvusClient getClient() {
        if (this.client == null) {
            lock.lock();
            try {
                if (this.client == null) {
                    this.client = this.configuration.getClient();
                    this.closeClient = false;

                    if (this.client == null) {
                        this.client = createClient();
                        this.closeClient = true;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        return this.client;
    }

    protected boolean pollDirectory(Exchange dynamic, String fileName, List<GenericFile<SftpRemoteFile>> fileList, int depth) {
        String currentDir = null;
        if (isStepwise()) {
             
             
            currentDir = operations.getCurrentDirectory();
        }

         
        fileName = FileUtil.stripTrailingSeparator(fileName);

        boolean answer = doPollDirectory(dynamic, fileName, null, fileList, depth);
        if (currentDir != null) {
            operations.changeCurrentDirectory(currentDir);
        }

        return answer;
    }

    protected boolean doHasNext() {
        try {
            if (zipInputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = currentEntry != null;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    zipInputStream.close();
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("aws")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("aws");
            if (pf instanceof SecretsManagerPropertiesFunction) {
                propertiesFunction = (SecretsManagerPropertiesFunction) pf;
            }
        }
        AwsVaultConfiguration aws = getCamelContext().getVaultConfiguration().getAwsVaultConfiguration();
        if (aws != null && aws.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(CloudTrailReloadTriggerTask.class);
        }
    }

    public void close() {
        if (acceptorThread != null) {
            lock.lock();
            try {
                try {
                     
                    if (serversocket != null) {
                        serversocket.close();
                    }
                } catch (IOException e) {
                    LOG.debug(e.getMessage(), e);
                } finally {
                    acceptorThread = null;
                    listenerService = null;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    protected void handleReplyMessage(String correlationID, Message message, Session session) {
        ReplyHandler handler = correlation.remove(correlationID);
        if (handler == null && endpoint.isUseMessageIDAsCorrelationID()) {
            handler = waitForProvisionCorrelationToBeUpdated(correlationID, message);
        }

        if (handler != null) {
            handler.onReply(correlationID, message, session);
        } else {
             
             
             
            log.warn(
                    "Reply received for unknown correlationID [{}] on reply destination [{}]. Current correlation map size: {}. The message will be ignored: {}",
                    correlationID, replyTo, correlation.size(), message);
        }
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotent(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentRepositoryReadLockStrategy readLockStrategy = new FileIdempotentRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        Integer readLockIdempotentReleaseDelay = (Integer) params.get("readLockIdempotentReleaseDelay");
        if (readLockIdempotentReleaseDelay != null) {
            readLockStrategy.setReadLockIdempotentReleaseDelay(readLockIdempotentReleaseDelay);
        }
        Boolean readLockIdempotentReleaseAsync = (Boolean) params.get("readLockIdempotentReleaseAsync");
        if (readLockIdempotentReleaseAsync != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsync(readLockIdempotentReleaseAsync);
        }
        Integer readLockIdempotentReleaseAsyncPoolSize = (Integer) params.get("readLockIdempotentReleaseAsyncPoolSize");
        if (readLockIdempotentReleaseAsyncPoolSize != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsyncPoolSize(readLockIdempotentReleaseAsyncPoolSize);
        }
        ScheduledExecutorService readLockIdempotentReleaseExecutorService
                = (ScheduledExecutorService) params.get("readLockIdempotentReleaseExecutorService");
        if (readLockIdempotentReleaseExecutorService != null) {
            readLockStrategy.setReadLockIdempotentReleaseExecutorService(readLockIdempotentReleaseExecutorService);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public static String[] splitSafeQuote(String input, char separator, boolean trim, boolean keepQuotes) {
        if (input == null) {
            return null;
        }

        if (input.indexOf(separator) == -1) {
            if (input.length() > 1) {
                char ch = input.charAt(0);
                char ch2 = input.charAt(input.length() - 1);
                boolean singleQuoted = ch == '\'' && ch2 == '\'';
                boolean doubleQuoted = ch == '"' && ch2 == '"';
                if (!keepQuotes && (singleQuoted || doubleQuoted)) {
                    input = input.substring(1, input.length() - 1);
                     
                } else if (trim) {
                    input = input.trim();
                }
            }
             
            return new String[] { input };
        }

        List<String> answer = new ArrayList<>();
        StringBuilder sb = new StringBuilder(input.length());

        boolean singleQuoted = false;
        boolean doubleQuoted = false;
        boolean separating = false;

        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            char prev = i > 0 ? input.charAt(i - 1) : 0;
            boolean isQuoting = singleQuoted || doubleQuoted;
            boolean last = i == input.length() - 1;

            if (!doubleQuoted && ch == '\'') {
                if (singleQuoted && prev == ch && sb.isEmpty()) {
                     
                    if (keepQuotes) {
                        answer.add("''");
                    } else {
                        answer.add("");
                    }
                }
                 
                if (last) {
                    if (singleQuoted && !sb.isEmpty()) {
                        String text = sb.toString();
                         
                        if (keepQuotes) {
                            answer.add(text + "'");  
                        } else {
                            answer.add(text);
                        }
                        sb.setLength(0);
                    }
                    break;  
                }
                singleQuoted = !singleQuoted;
                if (keepQuotes) {
                    sb.append(ch);
                }
                continue;
            } else if (!singleQuoted && ch == '"') {
                if (doubleQuoted && prev == ch && sb.isEmpty()) {
                     
                    if (keepQuotes) {
                        answer.add("\"");  
                    } else {
                        answer.add("");
                    }
                }
                 
                if (last) {
                    if (doubleQuoted && !sb.isEmpty()) {
                        String text = sb.toString();
                         
                        if (keepQuotes) {
                            answer.add(text + "\"");
                        } else {
                            answer.add(text);
                        }
                        sb.setLength(0);
                    }
                    break;  
                }
                doubleQuoted = !doubleQuoted;
                if (keepQuotes) {
                    sb.append(ch);
                }
                continue;
            } else if (!isQuoting && ch == separator) {
                separating = true;
                 
                if (!sb.isEmpty()) {
                    String text = sb.toString();
                    if (trim) {
                        text = text.trim();
                    }
                    answer.add(text);
                    sb.setLength(0);
                }
                 
                continue;
            }

            if (trim && !isQuoting && separating && separator != ' ' && ch == ' ') {
                continue;
            }
            separating = false;

             
            sb.append(ch);
        }

         
        if (!sb.isEmpty()) {
            String text = sb.toString();
            if (trim) {
                text = text.trim();
            }
            answer.add(text);
        }

        return answer.toArray(new String[0]);
    }

    private static List<String> gatherEnums(UriParam param, Class<?> fieldTypeElement) {
        if (!Strings.isNullOrEmpty(param.enums())) {
            String[] values = param.enums().split(",");
            return Stream.of(values).map(String::trim).toList();
        } else if (fieldTypeElement.isEnum()) {
            return doGatherFromEnum(fieldTypeElement);
        }

        return null;
    }

    private AlgorithmParameterSpec getDefaultParameterSpec(String algorithm) {
         
        try {
            switch (algorithm) {
                case "DILITHIUM":
                    return org.bouncycastle.pqc.jcajce.spec.DilithiumParameterSpec.dilithium2;
                case "MLDSA":
                case "SLHDSA":
                     
                    return null;
                case "FALCON":
                    return org.bouncycastle.pqc.jcajce.spec.FalconParameterSpec.falcon_512;
                case "SPHINCSPLUS":
                    return org.bouncycastle.pqc.jcajce.spec.SPHINCSPlusParameterSpec.sha2_128s;
                case "XMSS":
                    return new org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec(
                            10,
                            org.bouncycastle.pqc.jcajce.spec.XMSSParameterSpec.SHA256);
                case "XMSSMT":
                    return org.bouncycastle.pqc.jcajce.spec.XMSSMTParameterSpec.XMSSMT_SHA2_20d2_256;
                case "LMS":
                case "HSS":
                    return new org.bouncycastle.pqc.jcajce.spec.LMSKeyGenParameterSpec(
                            org.bouncycastle.pqc.crypto.lms.LMSigParameters.lms_sha256_n32_h10,
                            org.bouncycastle.pqc.crypto.lms.LMOtsParameters.sha256_n32_w4);
                case "MLKEM":
                case "KYBER":
                     
                    return null;
                case "NTRU":
                    return org.bouncycastle.pqc.jcajce.spec.NTRUParameterSpec.ntruhps2048509;
                case "NTRULPRime":
                    return org.bouncycastle.pqc.jcajce.spec.NTRULPRimeParameterSpec.ntrulpr653;
                case "SNTRUPrime":
                    return org.bouncycastle.pqc.jcajce.spec.SNTRUPrimeParameterSpec.sntrup761;
                case "SABER":
                    return org.bouncycastle.pqc.jcajce.spec.SABERParameterSpec.lightsaberkem128r3;
                case "FRODO":
                    return org.bouncycastle.pqc.jcajce.spec.FrodoParameterSpec.frodokem640aes;
                case "BIKE":
                    return org.bouncycastle.pqc.jcajce.spec.BIKEParameterSpec.bike128;
                case "HQC":
                    return org.bouncycastle.pqc.jcajce.spec.HQCParameterSpec.hqc128;
                case "CMCE":
                    return org.bouncycastle.pqc.jcajce.spec.CMCEParameterSpec.mceliece348864;
                default:
                    return null;
            }
        } catch (Exception e) {
            LOG.warn("Failed to create default parameter spec for algorithm: {}", algorithm, e);
            return null;
        }
    }

    public String dumpTracedMessagesAsJSon(String nodeId) {
        List<BacklogTracerEventMessage> events = dumpTracedMessages(nodeId);

        JsonObject root = new JsonObject();
        JsonArray arr = new JsonArray();
        root.put("traces", arr);
        for (BacklogTracerEventMessage event : events) {
            arr.add(event.asJSon());
        }
        return Jsoner.prettyPrint(root.toJson());
    }

    public static void setOut(Exchange exchange, Object payload) {
        if (payload instanceof DefaultExchangeHolder) {
            DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) payload);
        } else if (payload instanceof AddressedEnvelope) {
            @SuppressWarnings("unchecked")
            AddressedEnvelope<Object, InetSocketAddress> dp = (AddressedEnvelope<Object, InetSocketAddress>) payload;
             
            if (dp.content() instanceof DefaultExchangeHolder) {
                DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) dp.content());
            } else {
                 
                exchange.getOut().setBody(dp.content());
            }
             
            exchange.setProperty(NettyConstants.NETTY_REMOTE_ADDRESS, dp.sender());
        } else {
             
            exchange.getOut().setHeaders(exchange.getIn().getHeaders());
            exchange.getOut().setBody(payload);
        }
    }

    protected List<String> determineEncryptionUserIds(Exchange exchange) {
        String userid = findKeyUserid(exchange);
        List<String> userids = findKeyUserids(exchange);
         
        List<String> result;
        if (userid != null) {
            if (userids == null || userids.isEmpty()) {
                result = Collections.singletonList(userid);
            } else {
                result = new ArrayList<>(userids.size() + 1);
                result.add(userid);
                result.addAll(userids);
            }
        } else {
            if (userids == null || userids.isEmpty()) {
                throw new IllegalStateException("Cannot PGP encrypt message. No User ID of the public key specified.");
            }
            result = userids;
        }
        return result;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();

        for (int index = 0; index < total && isBatchAllowed(); index++) {
             
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());
             
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);

             
            pendingExchanges = total - index - 1;

             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
        }

        return total;
    }

    public void addRoutesBuilder(Class<?>... routeBuilder) {
        StringJoiner existing = new StringJoiner(",");
        if (routesBuilderClasses != null && !routesBuilderClasses.isEmpty()) {
            existing.add(routesBuilderClasses);
        }
        if (routeBuilder != null) {
            for (Class<?> clazz : routeBuilder) {
                existing.add(clazz.getName());
            }
        }
        setRoutesBuilderClasses(existing.toString());
    }

    private String getPrompt(Exchange exchange) {
        String prompt = exchange.getIn().getHeader(GoogleVertexAIConstants.PROMPT, String.class);
        if (prompt == null) {
            prompt = exchange.getIn().getBody(String.class);
        }
        if (prompt == null) {
            throw new IllegalArgumentException("Prompt must be provided in body or header");
        }
        return prompt;
    }

    private void processCloseJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.closeJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "message.key.columns", messageKeyColumns);
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "include.schema.changes", includeSchemaChanges);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "snapshot.lock.timeout.ms", snapshotLockTimeoutMs);
        addPropertyIfNotNull(configBuilder, "cdc.change.tables.schema", cdcChangeTablesSchema);
        addPropertyIfNotNull(configBuilder, "database.user", databaseUser);
        addPropertyIfNotNull(configBuilder, "database.dbname", databaseDbname);
        addPropertyIfNotNull(configBuilder, "datatype.propagate.source.type", datatypePropagateSourceType);
        addPropertyIfNotNull(configBuilder, "snapshot.tables.order.by.row.count", snapshotTablesOrderByRowCount);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.select.statement.overrides", snapshotSelectStatementOverrides);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.skip.unparseable.ddl", schemaHistoryInternalSkipUnparseableDdl);
        addPropertyIfNotNull(configBuilder, "column.include.list", columnIncludeList);
        addPropertyIfNotNull(configBuilder, "column.propagate.source.type", columnPropagateSourceType);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "table.exclude.list", tableExcludeList);
        addPropertyIfNotNull(configBuilder, "database.password", databasePassword);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.chunk.size", incrementalSnapshotChunkSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.store.only.captured.tables.ddl", schemaHistoryInternalStoreOnlyCapturedTablesDdl);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.store.only.captured.databases.ddl", schemaHistoryInternalStoreOnlyCapturedDatabasesDdl);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "decimal.handling.mode", decimalHandlingMode);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "cdc.control.schema", cdcControlSchema);
        addPropertyIfNotNull(configBuilder, "table.ignore.builtin", tableIgnoreBuiltin);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "time.precision.mode", timePrecisionMode);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "database.port", databasePort);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.history.internal", schemaHistoryInternal);
        addPropertyIfNotNull(configBuilder, "column.exclude.list", columnExcludeList);
        addPropertyIfNotNull(configBuilder, "database.hostname", databaseHostname);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "table.include.list", tableIncludeList);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        addPropertyIfNotNull(configBuilder, "db2.platform", db2Platform);
        
        return configBuilder.build();
    }

    public void put(String chatId, CamelToolSpecification specification) {
        if (tools.get(chatId) != null) {
            tools.get(chatId).add(specification);
        } else {
            Set<CamelToolSpecification> camelToolSpecifications = new LinkedHashSet<>();
            camelToolSpecifications.add(specification);
            tools.put(chatId, camelToolSpecifications);
        }
    }

    private static int getIndex(ParameterizedType type, TypeVariable<?> variable) {
        Type[] actualTypeArguments = type.getActualTypeArguments();
        for (int i = 0; i < actualTypeArguments.length; i++) {
            if (actualTypeArguments[i] instanceof TypeVariable) {
                TypeVariable<?> variableArgument = (TypeVariable<?>) actualTypeArguments[i];
                if (variableArgument.getName().equals(variable.getName())) {
                    return i;
                }
            }
        }
        return -1;
    }

    private void processStreamingRequest(
            InvokeModelWithResponseStreamRequest request,
            Exchange exchange) {

        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            Message message = getMessageForResponse(exchange);
            BedrockStreamHandler.StreamMetadata metadata = new BedrockStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createChunksHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createCompleteHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Invoke Model Streaming command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

    public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
        MetricsRoutePolicy answer = new MetricsRoutePolicy();
        answer.setMetricsRegistry(getMetricsRegistry());
        answer.setUseJmx(isUseJmx());
        answer.setJmxDomain(getJmxDomain());
        answer.setPrettyPrint(isPrettyPrint());
        answer.setRateUnit(getRateUnit());
        answer.setDurationUnit(getDurationUnit());
        if (namePattern != null) {
            answer.setNamePattern(namePattern);
        }
        return answer;
    }

    protected JsonObject waitForOutputFile(Path outputFile) {
        StopWatch watch = new StopWatch();
        long wait = 10000;
        while (watch.taken() < wait) {
            File f = outputFile.toFile();
            try {
                 
                Thread.sleep(20);

                if (Files.exists(outputFile) && f.length() > 0) {
                    String text = Files.readString(outputFile);
                    return (JsonObject) Jsoner.deserialize(text);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

    private void allHeadersMDC(Exchange exchange, boolean push) {
        for (String header : exchange.getIn().getHeaders().keySet()) {
            if (exchange.getIn().getHeader(header) != null) {
                if (push) {
                    MDC.put(header, exchange.getIn().getHeader(header, String.class));
                } else {
                    MDC.remove(header);
                }
            }
        }
    }

    private void doCreateOrUpdateDeployment(
            Exchange exchange, String operationName, Function<Resource<DeploymentConfig>, DeploymentConfig> operation) {
        String deploymentName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        DeploymentConfigSpec dcSpec
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_CONFIG_SPEC, DeploymentConfigSpec.class);
        if (ObjectHelper.isEmpty(deploymentName)) {
            LOG.error("{} a specific Deployment Config require specify a Deployment name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment Config require specify a pod name", operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Deployment Config require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment Config require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(dcSpec)) {
            LOG.error("{} a specific Deployment Config require specify a Deployment Config spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Deployment Config require specify a Deployment Config spec bean",
                            operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENTS_LABELS, Map.class);
        DeploymentConfig deploymentCreating = new DeploymentConfigBuilder().withNewMetadata().withName(deploymentName)
                .withLabels(labels).endMetadata().withSpec(dcSpec).build();
        DeploymentConfig deploymentConfig
                = operation.apply(getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).deploymentConfigs()
                        .inNamespace(namespaceName)
                        .resource(deploymentCreating));

        prepareOutboundMessage(exchange, deploymentConfig);
    }

            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                QueryJob queryJob = null;
                try {
                    queryJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            QueryJob.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(queryJob, responseHeaders, ex);
            }

    protected void copyLocalLibDependencies(Set<String> deps) throws Exception {
        for (String d : deps) {
            if (d.startsWith("lib:")) {
                Path libDirPath = Paths.get(BUILD_DIR, "lib");
                Files.createDirectories(libDirPath);
                String n = d.substring(4);
                Path sourcePath = Paths.get(n);
                Path targetPath = libDirPath.resolve(n);
                ExportHelper.safeCopy(sourcePath, targetPath, true, symbolicLink);
            }
        }
    }

    public static EipModel generateEipModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("model");
        EipModel model = new EipModel();
        parseModel(mobj, model);
        model.setAbstractModel(mobj.getBooleanOrDefault("abstract", false));
        model.setInput(mobj.getBooleanOrDefault("input", false));
        model.setOutput(mobj.getBooleanOrDefault("output", false));
        JsonObject mprp = (JsonObject) obj.get("properties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addOption(option);
            }
        }
        mprp = (JsonObject) obj.get("exchangeProperties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addExchangeProperty(option);
            }
        }
        return model;
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    private void handleResult(EntryInfo.CachedEntryInfo entryInfo, Throwable t) {
        try {
            if (t == null) {
                logWriter.updateState(entryInfo, LogEntry.EntryState.PROCESSED);
            } else {
                logWriter.updateState(entryInfo, LogEntry.EntryState.FAILED);
            }
        } catch (IOException e) {
            if (t == null) {
                LOG.error("Unable to update state: {}", e.getMessage(), e);
            } else {
                LOG.error("Unable to mark the record as failed: {}", e.getMessage(), e);
            }
        }
    }

    public Pinecone getClient() {
        lock.lock();
        try {
            if (this.client == null) {
                this.client = this.configuration.getClient();
                if (this.client == null) {
                    this.client = createClient();
                }
            }
            return this.client;
        } finally {
            lock.unlock();
        }
    }

        public void run() {
            FilterWatchListDeletable<Pod, PodList, PodResource> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().pods().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<Pod, PodList, PodResource> client
                        = getEndpoint().getKubernetesClient().pods().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<Pod, PodList, PodResource>) client.withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, Pod resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    private void doCreateOrUpdateService(
            Exchange exchange, String operationName, Function<Resource<Service>, Service> operation) {
        String serviceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ServiceSpec serviceSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_SPEC, ServiceSpec.class);
        if (ObjectHelper.isEmpty(serviceName)) {
            LOG.error("{} a specific service require specify a service name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a service name", operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific service require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(serviceSpec)) {
            LOG.error("{} a specific service require specify a service spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific service require specify a service spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_LABELS, Map.class);
        Service serviceCreating = new ServiceBuilder().withNewMetadata().withName(serviceName).withLabels(labels).endMetadata()
                .withSpec(serviceSpec).build();
        Service service
                = operation.apply(
                        getEndpoint().getKubernetesClient().services().inNamespace(namespaceName).resource(serviceCreating));

        prepareOutboundMessage(exchange, service);
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        Expression answer = null;
        if (block != null) {
            answer = block.createExpression(camelContext, expression);
        }
        if (answer == null) {
             
            answer = ExpressionBuilder.constantExpression("");
        }
        return answer;
    }

    private Object performOperation(Exchange exchange, StripeOperation operation, String method) throws Exception {
        switch (operation) {
            case CHARGES:
                return handleCharges(exchange, method);
            case CUSTOMERS:
                return handleCustomers(exchange, method);
            case PAYMENT_INTENTS:
                return handlePaymentIntents(exchange, method);
            case PAYMENT_METHODS:
                return handlePaymentMethods(exchange, method);
            case REFUNDS:
                return handleRefunds(exchange, method);
            case SUBSCRIPTIONS:
                return handleSubscriptions(exchange, method);
            case INVOICES:
                return handleInvoices(exchange, method);
            case PRODUCTS:
                return handleProducts(exchange, method);
            case PRICES:
                return handlePrices(exchange, method);
            case BALANCE_TRANSACTIONS:
                return handleBalanceTransactions(exchange, method);
            default:
                throw new IllegalArgumentException("Unsupported operation: " + operation);
        }
    }

    protected void initRouteTemplateRefs() throws Exception {
         
        if (getRouteTemplateRefs() != null) {
            for (RouteTemplateContextRefDefinition ref : getRouteTemplateRefs()) {
                List<RouteTemplateDefinition> defs = ref.lookupRouteTemplates(getContext());
                for (RouteTemplateDefinition def : defs) {
                    LOG.debug("Adding route template from {} -> {}", ref, def);
                    getRouteTemplates().add(def);
                }
            }
        }
    }

    public <T> Optional<T> newInstance(String key, Class<T> type) {
        maybeDownload(key);

        if (export && skip(key)) {
            return Optional.empty();
        }

        Optional<T> answer = super.newInstance(key, type);
        if (answer.isEmpty()) {
             
            final FactoryFinder finder
                    = camelContext.getCamelContextExtension().getFactoryFinder(PeriodTaskResolver.RESOURCE_PATH);
            T obj = ResolverHelper.resolveService(camelContext, finder, key, type).orElse(null);
            return Optional.ofNullable(obj);
        }
        return answer;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        InfluxDbEndpoint endpoint = new InfluxDbEndpoint(uri, this);
        endpoint.setConnectionBean(remaining);
        InfluxDB target = influxDB;
        if (target == null) {
             
            target = CamelContextHelper.mandatoryLookup(getCamelContext(), remaining, InfluxDB.class);
        }
        endpoint.setInfluxDB(target);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    private void queryById(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        String indexId = ExchangeHelper.getMandatoryHeader(exchange, WeaviateVectorDbHeaders.INDEX_ID, String.class);

         
         
        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        Result<List<WeaviateObject>> result = client.data().objectsGetter()
                .withClassName(collectionName)
                .withID(indexId)
                .run();

        populateResponse(result, exchange);
    }

    private void updateResourcePolicy(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String policyId = exchange.getIn().getHeader(KeycloakConstants.POLICY_ID, String.class);
        if (ObjectHelper.isEmpty(policyId)) {
            throw new IllegalArgumentException("Policy ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof PolicyRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().policies().policy(policyId)
                        .update((PolicyRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Policy updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update policy requires POJO request with PolicyRepresentation");
        }
    }

    private boolean sleep() {
        LOG.trace("Exclusive read lock not granted. Sleeping for {} millis.", checkInterval);
        try {
            Thread.sleep(checkInterval);
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.debug("Sleep interrupted while waiting for exclusive read lock, so breaking out");
            return true;
        }
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    private static void setAdditionalConfiguration(
            CamelContext camelContext, RestConfiguration config, DataFormat dataFormat, String prefix) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            PropertyBindingSupport.build().bind(camelContext, dataFormat, copy);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator != null) {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                             
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            } else {
                super.process(exchange, doneSync -> callback.done(false));
            }
        }));
        return false;
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    private org.openstack4j.model.compute.Flavor messageToFlavor(Message message) {
        Flavor flavor = message.getBody(Flavor.class);
        if (flavor == null) {
            Map headers = message.getHeaders();
            FlavorBuilder flavorBuilder = Builders.flavor();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            flavorBuilder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NovaConstants.VCPU)) {
                flavorBuilder.vcpus(message.getHeader(NovaConstants.VCPU, Integer.class));
            }

            if (headers.containsKey(NovaConstants.RAM)) {
                flavorBuilder.ram(message.getHeader(NovaConstants.RAM, Integer.class));
            }

            if (headers.containsKey(NovaConstants.DISK)) {
                flavorBuilder.disk(message.getHeader(NovaConstants.DISK, Integer.class));
            }

            if (headers.containsKey(NovaConstants.SWAP)) {
                flavorBuilder.swap(message.getHeader(NovaConstants.SWAP, Integer.class));
            }

            if (headers.containsKey(NovaConstants.RXTXFACTOR)) {
                flavorBuilder.rxtxFactor(message.getHeader(NovaConstants.RXTXFACTOR, Integer.class));
            }

            flavor = flavorBuilder.build();
        }

        return flavor;
    }

    public <T> T getHeader(String name, Class<T> type) {
        Object value = null;

        if (headers == null) {
             
            headers = createHeaders();
        }

        if (!headers.isEmpty()) {
            value = headers.get(name);
        }
        if (value == null) {
             
            if (boolean.class == type) {
                return (T) Boolean.FALSE;
            }
            return null;
        }

         
         
        if (type.isInstance(value)) {
            return (T) value;
        }

        Exchange e = getExchange();
        if (e != null) {
            return typeConverter.convertTo(type, e, value);
        } else {
            return typeConverter.convertTo(type, value);
        }
    }

    public void process(Exchange exchange) throws Exception {
        Object payload = exchange.getMessage().getBody();
        if (payload == null) {
            return;
        }

        AvroSchema answer = computeIfAbsent(exchange);

        if (answer != null) {
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA, answer);
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA_TYPE, SchemaType.AVRO.type());
            exchange.setProperty(SchemaHelper.CONTENT_CLASS, SchemaHelper.resolveContentClass(exchange, this.contentClass));
        }
    }

    public String getStringOrDefault(final String key, final String defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable instanceof Boolean) {
            returnable = returnable.toString();
        } else if (returnable instanceof Number) {
            returnable = returnable.toString();
        }
        return (String) returnable;
    }

    public <T extends ManagedProcessorMBean> T getManagedProcessor(String id, Class<T> type) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Processor processor = camelContext.getProcessor(id);
        ProcessorDefinition<?> def
                = camelContext.getCamelContextExtension().getContextPlugin(Model.class).getProcessorDefinition(id);

         
        if (def != null) {
            try {
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy()
                        .getObjectNameForProcessor(camelContext, processor, def);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, type);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    protected void doStart() throws Exception {
        super.doStart();
        cache = CamelContextHelper.lookup(getCamelContext(), cacheName, Cache.class);
        if (cache == null) {
            if (configuration.isCreateCacheIfNotExist()) {
                cache = getComponent().getOrCreateCache(cacheName, configuration);
            } else {
                throw new IllegalArgumentException(
                        "Cache instance '" + cacheName + "' not found and createCacheIfNotExist is set to false");
            }
        }
    }

    public void process(Exchange exchange) throws Exception {

        ClientConfigurations clientConfigurations = new ClientConfigurations();

        if (obsClient == null) {
            this.obsClient = endpoint.initClient();
        }

        updateClientConfigs(exchange, clientConfigurations);

        switch (clientConfigurations.getOperation()) {
            case OBSOperations.LIST_BUCKETS:
                listBuckets(exchange);
                break;
            case OBSOperations.CREATE_BUCKET:
                createBucket(exchange, clientConfigurations);
                break;
            case OBSOperations.DELETE_BUCKET:
                deleteBucket(exchange, clientConfigurations);
                break;
            case OBSOperations.CHECK_BUCKET_EXISTS:
                checkBucketExists(exchange, clientConfigurations);
                break;
            case OBSOperations.GET_BUCKET_METADATA:
                getBucketMetadata(exchange, clientConfigurations);
                break;
            case OBSOperations.LIST_OBJECTS:
                listObjects(exchange, clientConfigurations);
                break;
            case OBSOperations.GET_OBJECT:
                getObject(exchange, clientConfigurations);
                break;
            case OBSOperations.PUT_OBJECT:
                putObject(exchange, clientConfigurations);
                break;
            default:
                throw new UnsupportedOperationException(
                        String.format("%s is not a supported operation", clientConfigurations.getOperation()));
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.BulkRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toBulkRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.DeleteRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toDeleteRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.GetRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toGetRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.IndexRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toIndexRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.MgetRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toMgetRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.SearchRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toSearchRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.core.UpdateRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toUpdateRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, co.elastic.clients.elasticsearch.indices.DeleteIndexRequest.Builder.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.es.converter.ElasticsearchActionRequestConverter.toDeleteIndexRequestBuilder(value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        SolrConfiguration config = new SolrConfiguration();
        config.setSolrClient(this.getSolrClient());
        config.setHost(this.getHost());
        config.setPort(this.getPort());
        config.setCollection(this.getDefaultCollection());
        config.setRequestTimeout(this.getRequestTimeout());
        config.setConnectionTimeout(this.getConnectionTimeout());
        config.setEnableSSL(this.isEnableSSL());
        config.setUsername(this.getUsername());
        config.setPassword(this.getPassword());
        config.configure(uri);

        Endpoint endpoint = new SolrEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

         
         
        if (config.getCollection() == null && config.getSolrClient() != null) {
            config.setCollection(config.getSolrClient().getDefaultCollection());
        }

        return endpoint;
    }

                public void eventReceived(Action action, Deployment resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

        DateTimeFormatter getDateFormat() {
            DateTimeFormatter result;
            if (locale != null) {
                result = DateTimeFormatter.ofPattern(pattern, locale)
                        .withZone(zone);
            } else {
                result = DateTimeFormatter.ofPattern(pattern)
                        .withZone(zone);
            }
            return result;
        }

    public ZipIterator(Exchange exchange, InputStream inputStream) {
        this.exchange = exchange;
        this.allowEmptyDirectory = false;

        Objects.requireNonNull(inputStream);

        if (inputStream instanceof ZipArchiveInputStream) {
            zipInputStream = (ZipArchiveInputStream) inputStream;
        } else {
            try {
                ArchiveInputStream input = new ArchiveStreamFactory().createArchiveInputStream(ArchiveStreamFactory.ZIP,
                        new BufferedInputStream(inputStream));
                zipInputStream = (ZipArchiveInputStream) input;
            } catch (ArchiveException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
        parent = null;
        first = true;
    }

  protected static final String addEscapes(String str) {
    StringBuilder retval = new StringBuilder();
    char ch;
    for (int i = 0; i < str.length(); i++) {
      switch (str.charAt(i))
      {
        case '\b':
          retval.append("\\b");
          continue;
        case '\t':
          retval.append("\\t");
          continue;
        case '\n':
          retval.append("\\n");
          continue;
        case '\f':
          retval.append("\\f");
          continue;
        case '\r':
          retval.append("\\r");
          continue;
        case '\"':
          retval.append("\\\"");
          continue;
        case '\'':
          retval.append("\\\'");
          continue;
        case '\\':
          retval.append("\\\\");
          continue;
        default:
          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
            String s = "0000" + Integer.toString(ch, 16);
            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
          } else {
            retval.append(ch);
          }
          continue;
      }
    }
    return retval.toString();
  }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Integer pos = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_POS)) {
            if (!(headers.get(HazelcastConstants.OBJECT_POS) instanceof Integer)) {
                throw new IllegalArgumentException("OBJECT_POS Should be of type Integer");
            }
            pos = (Integer) headers.get(HazelcastConstants.OBJECT_POS);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {

            case ADD:
                this.add(pos, exchange);
                break;

            case GET:
                this.get(pos, exchange);
                break;

            case SET_VALUE:
                this.set(pos, exchange);
                break;

            case REMOVE_VALUE:
                this.remove(pos, exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case ADD_ALL:
                this.addAll(pos, exchange);
                break;

            case REMOVE_ALL:
                this.removeAll(exchange);
                break;

            case RETAIN_ALL:
                this.retainAll(exchange);
                break;

            case GET_ALL:
                this.getAll(exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the LIST cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

        public void run() {
            FilterWatchListDeletable<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).deploymentConfigs().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>> client
                        = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).deploymentConfigs()
                                .inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<DeploymentConfig, DeploymentConfigList, DeployableScalableResource<DeploymentConfig>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, DeploymentConfig resource) {
                    DeploymentConfigEvent de = new DeploymentConfigEvent(action, resource);
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(de.getDeploymentConfig());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, de.getAction());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }

                }
            });
        }

    public boolean release(Exchange exchange) {
        try {
             
            PooledExchange ee = (PooledExchange) exchange;
            ee.done();

             
            boolean inserted = pool.offer(exchange);

            if (statisticsEnabled) {
                if (inserted) {
                    statistics.released.increment();
                } else {
                    statistics.discarded.increment();
                }
            }
            return inserted;
        } catch (Exception e) {
            if (statisticsEnabled) {
                statistics.discarded.increment();
            }
            LOG.debug("Error resetting exchange: {}. This exchange is discarded.", exchange);
            return false;
        }
    }

    private String loadJavaSource(String className) {
        try {
            Path file = getSourceRoots().stream()
                    .map(d -> d.resolve(className.replace('.', '/') + ".java"))
                    .filter(Files::isRegularFile)
                    .findFirst()
                    .orElse(null);

            if (file == null) {
                throw new FileNotFoundException("Unable to find source for " + className);
            }
            return PackageHelper.loadText(file);
        } catch (IOException e) {
            String classpath;
            try {
                classpath = project.getCompileClasspathElements().toString();
            } catch (Exception e2) {
                classpath = e2.toString();
            }
            throw new RuntimeException(
                    "Unable to load source for class " + className + " in folders " + getSourceRoots()
                                       + " (classpath: " + classpath + ")");
        }
    }

        public Optional<CamelClusterService> select(Collection<CamelClusterService> services) {
            Optional<Map.Entry<Integer, List<CamelClusterService>>> highPriorityServices = services.stream()
                    .collect(Collectors.groupingBy(CamelClusterService::getOrder))
                    .entrySet().stream()
                    .min(Comparator.comparingInt(Map.Entry::getKey));

            if (highPriorityServices.isPresent()) {
                if (highPriorityServices.get().getValue().size() == 1) {
                    return Optional.of(highPriorityServices.get().getValue().iterator().next());
                } else {
                    LOGGER.warn("Multiple CamelClusterService instances available for highest priority (order={}, items={})",
                            highPriorityServices.get().getKey(),
                            highPriorityServices.get().getValue());
                }
            }

            return Optional.empty();
        }

    public int getPort() {
        if (uri.getPort() == -1) {
            if ("cometds".equals(getProtocol())) {
                return 443;
            } else {
                return 80;
            }
        }
        return uri.getPort();
    }

    private StopContainerCmd executeStopContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Stop Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        StopContainerCmd stopContainerCmd = client.stopContainerCmd(containerId);

        Integer timeout = DockerHelper.getProperty(DockerConstants.DOCKER_TIMEOUT, configuration, message, Integer.class);

        if (timeout != null) {
            stopContainerCmd.withTimeout(timeout);
        }

        return stopContainerCmd;

    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());

                        JsonObject jv = (JsonObject) root.get("variables");
                        if (jv != null) {
                            for (String id : jv.keySet()) {
                                JsonArray arr = jv.getCollection(id);
                                if (arr != null) {
                                    for (int i = 0; i < arr.size(); i++) {
                                        row = row.copy();
                                        JsonObject jo = (JsonObject) arr.get(i);
                                        row.id = id;
                                        row.key = jo.getString("key");
                                        row.type = jo.getString("type");
                                        row.value = jo.get("value");
                                        rows.add(row);
                                    }
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("REPO").headerAlign(HorizontalAlign.CENTER).with(r -> r.id),
                    new Column().header("TYPE").headerAlign(HorizontalAlign.CENTER)
                            .maxWidth(40, OverflowBehaviour.ELLIPSIS_LEFT).with(r -> r.type),
                    new Column().header("KEY").dataAlign(HorizontalAlign.LEFT).maxWidth(50, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.key),
                    new Column().header("VALUE").headerAlign(HorizontalAlign.RIGHT).maxWidth(80, OverflowBehaviour.NEWLINE)
                            .with(this::getValue))));
        }

        return 0;
    }

    private static String readClassFromCamelResource(File file, StringBuilder buffer, BuildContext buildContext)
            throws MojoExecutionException {
         
         
        if (file.isDirectory()) {
            return null;
        }
        String name = file.getName();
        if (name.charAt(0) != '.') {
            if (!buffer.isEmpty()) {
                buffer.append(" ");
            }
            buffer.append(name);
        }

        if (!buildContext.hasDelta(file)) {
             
             
             
             
            return null;
        }

         
        try {
            String text = PackageHelper.loadText(file);
            Map<String, String> map = PackageHelper.parseAsMap(text);
            return map.get("class");
        } catch (IOException e) {
            throw new MojoExecutionException("Failed to read file " + file + ". Reason: " + e, e);
        }
    }

    public GoogleSheetsConfiguration getEndpointConfiguration(GoogleSheetsApiName apiName) {
        GoogleSheetsConfiguration result = null;
        switch (apiName) {
            case SPREADSHEETS:
                result = new SheetsSpreadsheetsEndpointConfiguration();
                break;
            case DATA:
                result = new SheetsSpreadsheetsValuesEndpointConfiguration();
                break;
        }
        return result;
    }

    private void listSecrets(SecretManagerServiceClient client, Exchange exchange) throws InvalidPayloadException {
        SecretManagerServiceClient.ListSecretsPagedResponse response;
        if (getConfiguration().isPojoRequest()) {
            ListSecretsRequest request = exchange.getIn().getMandatoryBody(ListSecretsRequest.class);
            response = client.listSecrets(request);
        } else {
            String projectId = getConfiguration().getProject();
            response = client.listSecrets(ProjectName.of(projectId));
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    public Message toCamelMessage(InboundStreamHttpRequest request, Exchange exchange, NettyHttpConfiguration configuration)
            throws Exception {
        LOG.trace("toCamelMessage: {}", request);

        NettyHttpMessage answer = new NettyHttpMessage(exchange.getContext(), null, null);
        answer.setExchange(exchange);
        if (configuration.isMapHeaders()) {
            populateCamelHeaders(request.getHttpRequest(), answer.getHeaders(), exchange, configuration);
        }

        answer.setBody(request.getInputStream());
        return answer;
    }

    private static GenericFileExclusiveReadLockStrategy getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy strategy
                = (GenericFileExclusiveReadLockStrategy) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<SftpRemoteFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                SftpChangedExclusiveReadLockStrategy readLockStrategy = new SftpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public static Stream<String> combine(String... items) {
        Set<String> answer = new TreeSet<>();

        for (String item : items) {
            if (item == null) {
                continue;
            }

            String[] elements = item.split(",");
            answer.addAll(Arrays.asList(elements));
        }

        return answer.stream();
    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception {
        IBaseResource iBaseResource;
        if (!(o instanceof IBaseResource)) {
            iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o);
        } else {
            iBaseResource = (IBaseResource) o;
        }

        IParser parser = getFhirContext().newJsonParser();
        configureParser(parser);
        parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream));

        if (isContentTypeHeader()) {
            exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy());
        }
    }

    private Initiator createInitiator(
            Application application, SessionSettings settings,
            MessageStoreFactory messageStoreFactory, LogFactory sessionLogFactory,
            MessageFactory messageFactory, ThreadModel threadModel)
            throws ConfigError {

        Initiator initiator;
        if (threadModel == ThreadModel.ThreadPerSession) {
            initiator = new ThreadedSocketInitiator(
                    application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else if (threadModel == ThreadModel.ThreadPerConnector) {
            initiator = new SocketInitiator(application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else {
            throw new ConfigError("Unknown thread mode: " + threadModel);
        }
        return initiator;
    }

    public static Predicate isNotEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return false;
                } else if (leftValue == null || rightValue == null) {
                     
                    return true;
                }

                return ObjectHelper.typeCoerceNotEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue);
            }

            protected String getOperationText() {
                return "!=";
            }
        };
    }

                public Phase getPhase() {
                    if (error.getPhase() != null) {
                        switch (error.getPhase()) {
                            case START:
                                return Phase.START;
                            case STOP:
                                return Phase.STOP;
                            case SUSPEND:
                                return Phase.SUSPEND;
                            case RESUME:
                                return Phase.RESUME;
                            case SHUTDOWN:
                                return Phase.SHUTDOWN;
                            case REMOVE:
                                return Phase.REMOVE;
                            default:
                                throw new IllegalStateException();
                        }
                    }
                    return null;
                }

    protected void doStart() throws Exception {
        super.doStart();
        final SalesforceEndpointConfig configuration = endpoint.getConfiguration();
        final String apiVersion = configuration.getApiVersion();

        compositeClient = new DefaultCompositeSObjectCollectionsApiClient(
                configuration, apiVersion, session, httpClient, loginConfig);

        if (classMap == null) {
            this.classMap = endpoint.getComponent().getClassMap();
        }
        ServiceHelper.startService(compositeClient);
    }

    private void queryById(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        String indexId = ExchangeHelper.getMandatoryHeader(exchange, WeaviateVectorDbHeaders.INDEX_ID, String.class);

         
         
        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        Result<List<WeaviateObject>> result = client.data().objectsGetter()
                .withClassName(collectionName)
                .withID(indexId)
                .run();

        populateResponse(result, exchange);
    }

        void cleanUpTempFile() {
             
            try {
                if (tempFile != null) {
                    FileUtil.deleteFile(tempFile);
                    tempFile = null;
                }
            } catch (Exception e) {
                LOG.warn("Error deleting temporary cache file: {}. This exception will be ignored.", tempFile, e);
            }
        }

    private SftpRemoteFile[] pollNamedFile() {
        SftpRemoteFile[] files = null;

         
         
        Exchange dummy = ExchangeHelper.getDummy(getEndpoint().getCamelContext());
        String name = evaluateFileExpression(dummy);
        if (name != null) {
            SftpRemoteFile file = new SftpRemoteFileSingle(name);
            files = new SftpRemoteFile[1];
            files[0] = file;
        }

        return files;
    }

        XmlSignatureChecker.Input build() {
            return new XmlSignatureChecker.Input() {

                @Override
                public boolean isXmlSchemaValidationExecuted() {
                    return xmlSchemaValidationExecuted;
                }

                @Override
                public int getTotalCountOfSignatures() {
                    return totalCountOfSignatures;
                }

                @Override
                public SignedInfo getSignedInfo() {
                    return signedInfo;
                }

                @Override
                public SignatureValue getSignatureValue() {
                    return signatureValue;
                }

                @Override
                public List<? extends XMLObject> getObjects() {
                    return objects;
                }

                @Override
                public Document getMessageBodyDocument() {
                    return messageBodyDocument;
                }

                @Override
                public Message getMessage() {
                    return message;
                }

                @Override
                public KeyInfo getKeyInfo() {
                    return keyInfo;
                }

                @Override
                public Element getCurrentSignatureElement() {
                    return currentSignatureElement;
                }

                @Override
                public int getCurrentCountOfSignatures() {
                    return currentCountOfSignatures;
                }
            };
        }

    public BigDecimal getBigDecimal(final String key) {
        Object returnable = this.get(key);
        if (returnable instanceof BigDecimal) {
             
        } else if (returnable instanceof Number) {
             
            returnable = new BigDecimal(returnable.toString());
        } else if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return (BigDecimal) returnable;
    }

    protected void doAdd(Exchange exchange, String operation) throws GitAPIException {
        String fileName = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME))) {
            fileName = exchange.getIn().getHeader(GitConstants.GIT_FILE_NAME, String.class);
        } else {
            throw new IllegalArgumentException("File name must be specified to execute " + operation);
        }
        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            git.add().addFilepattern(fileName).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

        public void fromAdmin(Message message, SessionID sessionID)
                throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {
            try {
                dispatch(QuickfixjEventCategory.AdminMessageReceived, sessionID, message);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                rethrowIfType(e, FieldNotFound.class);
                rethrowIfType(e, IncorrectDataFormat.class);
                rethrowIfType(e, IncorrectTagValue.class);
                rethrowIfType(e, RejectLogon.class);
                throw new DispatcherException(e);
            }
        }

    protected String getDelta(Row r) {
        if (r.delta != null) {
            if (r.delta.startsWith("-")) {
                return r.delta;
            } else if (!"0".equals(r.delta)) {
                 
                return "+" + r.delta;
            }
        }
        return r.delta;
    }

    protected Endpoint createEndpoint(final String uri, final String remaining, final Map<String, Object> parameters)
            throws Exception {
        RestOpenApiEndpoint endpoint = new RestOpenApiEndpoint(uri, remaining, this, parameters);
        endpoint.setApiContextPath(getApiContextPath());
        endpoint.setBasePath(getBasePath());
        endpoint.setBindingPackageScan(getBindingPackageScan());
        endpoint.setClientRequestValidation(isClientRequestValidation());
        endpoint.setClientResponseValidation(isClientResponseValidation());
        endpoint.setComponentName(getComponentName());
        endpoint.setConsumerComponentName(getConsumerComponentName());
        endpoint.setConsumes(getConsumes());
        if (getHost() != null) {
            endpoint.setHost(getHost());
        }
        endpoint.setProduces(getProduces());
        endpoint.setRequestValidationEnabled(isRequestValidationEnabled());
        if (getSpecificationUri() != null) {
            endpoint.setSpecificationUri(getSpecificationUri());
        }
        endpoint.setMissingOperation(getMissingOperation());
        endpoint.setMockIncludePattern(getMockIncludePattern());
        endpoint.setRestOpenapiProcessorStrategy(getRestOpenapiProcessorStrategy());
        setProperties(endpoint, parameters);
        return endpoint;
    }

    private void processConverseStreamingRequest(ConverseStreamRequest request, Exchange exchange) {
        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            org.apache.camel.Message message = getMessageForResponse(exchange);
            org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata metadata
                    = new org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createChunksHandler(
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createCompleteHandler(
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Converse Stream command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

    public void setCommitmentTypeQualifiers(List<String> commitmentTypeQualifiers) {
        if (commitmentTypeQualifiers == null) {
            throw new IllegalArgumentException("Parameter 'commitmentTypeQualifiers' is null");
        }
        for (String qualifier : commitmentTypeQualifiers) {
            if (qualifier == null || qualifier.isEmpty()) {
                throw new IllegalArgumentException("At least one qualifier of the commitment type is null or empty");
            }
        }
        this.commitmentTypeQualifiers = new ArrayList<>(commitmentTypeQualifiers);
    }

    private void doUpdateList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Updating: {} using statement: {}", in, statement);
            result = session.update(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public CamelCatalog getCatalog(boolean download) {
        if (catalog == null) {
            try {
                catalog = CatalogHelper.loadCatalog(RuntimeType.quarkus, RuntimeType.QUARKUS_VERSION, download);
            } catch (Exception e) {
                throw new RuntimeCamelException("Failed to create default Quarkus Camel catalog", e);
            }
        }

        return catalog;
    }

    public static String extractSourceName(String loc) {
        loc = stripSourceLocationLineNumber(loc);
        if (loc != null) {
            if (loc.contains(":")) {
                 
                loc = loc.substring(loc.indexOf(':') + 1);
                 
                loc = FileUtil.stripPath(loc);
            }
        }
        return loc;
    }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping RocketMQReplyManager: {} from processing replies from : {}", replyManager,
                            getEndpoint().getReplyToTopic());
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

    public SmppMessage createSmppMessage(CamelContext camelContext, AlertNotification alertNotification) {
        SmppMessage smppMessage = new SmppMessage(camelContext, alertNotification, configuration);

        smppMessage.setHeader(SmppConstants.MESSAGE_TYPE, SmppMessageType.AlertNotification.toString());
        smppMessage.setHeader(SmppConstants.SEQUENCE_NUMBER, alertNotification.getSequenceNumber());
        smppMessage.setHeader(SmppConstants.COMMAND_ID, alertNotification.getCommandId());
        smppMessage.setHeader(SmppConstants.COMMAND_STATUS, alertNotification.getCommandStatus());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR, alertNotification.getSourceAddr());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_NPI, alertNotification.getSourceAddrNpi());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_TON, alertNotification.getSourceAddrTon());
        smppMessage.setHeader(SmppConstants.ESME_ADDR, alertNotification.getEsmeAddr());
        smppMessage.setHeader(SmppConstants.ESME_ADDR_NPI, alertNotification.getEsmeAddrNpi());
        smppMessage.setHeader(SmppConstants.ESME_ADDR_TON, alertNotification.getEsmeAddrTon());

        return smppMessage;
    }

    protected void doStop() throws Exception {
        if (listenerContainer != null) {

            if (getEndpoint().isAsyncStopListener()) {
                getEndpoint().getAsyncStartStopExecutorService().submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            stopAndDestroyListenerContainer();
                        } catch (Exception e) {
                            LOG.warn("Error stopping listener container on destination: {}. This exception will be ignored.",
                                    getDestinationName(), e);
                        }
                    }

                    @Override
                    public String toString() {
                        return "AsyncStopListenerTask[" + getDestinationName() + "]";
                    }
                });
            } else {
                stopAndDestroyListenerContainer();
            }
        }

        super.doStop();
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    private MessageListener createConnectionListener() {
        return (channel, message) -> component.getHttpClient().getWorkerPool().execute(() -> {
            LOG.debug("[CHANNEL:META_CONNECT]: {}", message);

            if (!message.isSuccessful()) {
                LOG.warn("Connect failure: {}", message);
                connectError = (String) message.get(ERROR_FIELD);
                connectException = getFailure(message);

                if (connectError != null && connectError.equals(AUTHENTICATION_INVALID)) {
                    LOG.debug("connectError: {}", connectError);
                    LOG.debug("Attempting login...");
                    session.attemptLoginUntilSuccessful(backoffIncrement, maxBackoff);
                }
                if (message.getAdvice() == null || "none".equals(message.getAdvice().get("reconnect"))) {
                    LOG.debug("Advice == none, so handshaking");
                    client.handshake();
                }
            } else if (!channelsToSubscribe.isEmpty()) {
                LOG.info("Subscribing to channels: {}", channelsToSubscribe);
                for (var channelName : channelsToSubscribe) {
                    for (var consumer : channelToConsumers.get(channelName)) {
                        subscribe(consumer);
                    }
                }
            }
        });
    }

    protected String getHttpURL(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    private String fireListeners(Exchange exchange, String message) {
        if (listeners == null || listeners.isEmpty()) {
            return message;
        }
        for (LogListener listener : listeners) {
            if (listener == null) {
                continue;
            }
            try {
                String output = listener.onLog(exchange, logger, message);
                message = output != null ? output : message;
            } catch (Exception t) {
                LOG.warn("Ignoring an exception thrown by {}: {}", listener.getClass().getName(), t.getMessage());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("", t);
                }
            }
        }
        return message;
    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    private SSLContext createSSLContext(CamelContext camelContext, NettyServerBootstrapConfiguration configuration)
            throws Exception {
        if (!configuration.isSsl()) {
            return null;
        }

        SSLContext answer;

         
        if (configuration.getSslContextParameters() != null) {
            answer = configuration.getSslContextParameters().createSSLContext(camelContext);
        } else {
            SSLEngineFactory sslEngineFactory = new SSLEngineFactory();
            answer = sslEngineFactory.createSSLContext(camelContext,
                    configuration.getKeyStoreFormat(),
                    configuration.getSecurityProvider(),
                    configuration.getKeyStoreResource(),
                    configuration.getTrustStoreResource(),
                    configuration.getPassphrase().toCharArray());
        }

        return answer;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("blocked");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("exchanges");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.exchangeId = jo.getString("exchangeId");
                                    row.routeId = jo.getString("routeId");
                                    row.nodeId = jo.getString("nodeId");
                                    row.duration = jo.getLong("duration");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("EXCHANGE-ID").dataAlign(HorizontalAlign.LEFT).with(r -> r.exchangeId),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.routeId),
                    new Column().header("ID").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.nodeId),
                    new Column().header("DURATION").dataAlign(HorizontalAlign.RIGHT).with(this::getDuration))));
        }

        return 0;
    }

    private void createClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                Response response = keycloakClient.realm(realmName).clientScopes().create((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientScopeRepresentation clientScope = new ClientScopeRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME))) {
                String scopeName = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_NAME, String.class);
                clientScope.setName(scopeName);
            } else {
                throw new IllegalArgumentException("Client scope name must be specified");
            }
            Response response = keycloakClient.realm(realmName).clientScopes().create(clientScope);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private static String doLoad(File file, String kind) {
        try {
            String json = PackageHelper.loadText(file);
            if (Objects.equals(kind, PackageHelper.getSchemaKind(json))) {
                return json;
            }
        } catch (IOException ignored) {
             
        }
        return null;
    }

    public String getTraceLabel() {
        StringBuilder sb = new StringBuilder(256);
        sb.append("setHeaders[");
        int headerIndex = 0;
        for (Expression expression : expressions) {
            if (headerIndex > 0) {
                sb.append("; ");
            }
            sb.append(headerNames.get(headerIndex++).toString());
            sb.append(", ");
            sb.append(expression.toString());
        }
        sb.append("]");
        return sb.toString();
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    protected void decode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            delegateDecoder.decode(ctx, (ByteBuf) msg.content(), out);
            byte[] content = (byte[]) out.remove(out.size() - 1);
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(content, msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    public Consumer createConsumer(Processor processor) throws Exception {
        Consumer consumer;
        if (getConfiguration().isConsumeAsClient()) {
            consumer = new VertxWebsocketClientConsumer(this, processor);
        } else {
            consumer = new VertxWebsocketConsumer(this, processor);
        }
        configureConsumer(consumer);
        return consumer;
    }

    public Set<PosixFilePermission> getDirectoryPermissions() {
        Set<PosixFilePermission> permissions = EnumSet.noneOf(PosixFilePermission.class);
        if (ObjectHelper.isEmpty(chmodDirectory)) {
            return permissions;
        }

         
        String chmodString = chmodDirectory.substring(chmodDirectory.length() - 3);

        int ownerValue = Integer.parseInt(chmodString.substring(0, 1));
        int groupValue = Integer.parseInt(chmodString.substring(1, 2));
        int othersValue = Integer.parseInt(chmodString.substring(2, 3));

        if ((ownerValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_WRITE);
        }
        if ((ownerValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_READ);
        }
        if ((ownerValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_EXECUTE);
        }

        if ((groupValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_WRITE);
        }
        if ((groupValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_READ);
        }
        if ((groupValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_EXECUTE);
        }

         
        if ((othersValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_WRITE);  
        }
        if ((othersValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_READ);  
        }
        if ((othersValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_EXECUTE);  
        }

        return permissions;
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Integer pos = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_POS)) {
            if (!(headers.get(HazelcastConstants.OBJECT_POS) instanceof Integer)) {
                throw new IllegalArgumentException("OBJECT_POS Should be of type Integer");
            }
            pos = (Integer) headers.get(HazelcastConstants.OBJECT_POS);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {

            case ADD:
                this.add(pos, exchange);
                break;

            case GET:
                this.get(pos, exchange);
                break;

            case SET_VALUE:
                this.set(pos, exchange);
                break;

            case REMOVE_VALUE:
                this.remove(pos, exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case ADD_ALL:
                this.addAll(pos, exchange);
                break;

            case REMOVE_ALL:
                this.removeAll(exchange);
                break;

            case RETAIN_ALL:
                this.retainAll(exchange);
                break;

            case GET_ALL:
                this.getAll(exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the LIST cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean answer = it.hasNext();
        if (!answer) {
             
            try {
                close();
            } catch (IOException e) {
                 
            }
        }
        return answer;
    }

    public PullRequestFilesProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_PULL_REQUEST_SERVICE);
        if (service != null) {
            LOG.debug("Using PullRequestService found in registry {}", service.getClass().getCanonicalName());
            pullRequestService = (PullRequestService) service;
        } else {
            pullRequestService = new PullRequestService();
        }
        initService(pullRequestService);
    }

    protected void initRouteConfigurationRefs() throws Exception {
         
        if (getRouteConfigurationRefs() != null) {
            for (RouteConfigurationContextRefDefinition ref : getRouteConfigurationRefs()) {
                List<RouteConfigurationDefinition> defs = ref.lookupRouteConfigurations(getContext());
                for (RouteConfigurationDefinition def : defs) {
                    LOG.debug("Adding route configuration from {} -> {}", ref, def);
                    getRouteConfigurations().add(def);
                }
            }
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ReplicationControllerList rcList;
        if (ObjectHelper.isEmpty(namespace)) {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inAnyNamespace().list();
        } else {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, rcList.getItems());
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (folder == null) {
             
            return;
        }
        if (!scheduler) {
             
            return;
        }

        File dir = new File(folder);
        if (dir.exists() && dir.isDirectory()) {
            String msg = startupMessage(dir);
            if (msg != null) {
                LOG.info(msg);
            }

            WatchEvent.Modifier modifier = null;

             
            String os = ObjectHelper.getSystemProperty("os.name", "");
            if (os.toLowerCase(Locale.US).startsWith("mac")) {
                 
                Class<WatchEvent.Modifier> clazz = getCamelContext().getClassResolver()
                        .resolveClass("com.sun.nio.file.SensitivityWatchEventModifier", WatchEvent.Modifier.class);
                if (clazz != null) {
                    WatchEvent.Modifier[] modifiers = clazz.getEnumConstants();
                    for (WatchEvent.Modifier mod : modifiers) {
                        if ("HIGH".equals(mod.name())) {
                            modifier = mod;
                            break;
                        }
                    }
                }
                if (modifier != null) {
                    LOG.debug(
                            "On Mac OS X the JDK WatchService is slow by default so enabling SensitivityWatchEventModifier.HIGH as workaround");
                } else {
                    LOG.warn(
                            "On Mac OS X the JDK WatchService is slow and it may take up till 10 seconds to notice file changes");
                }
            }

            try {
                Path path = dir.toPath();
                watcher = path.getFileSystem().newWatchService();
                 
                if (isRecursive) {
                    this.folderKeys = new HashMap<>();
                    registerRecursive(watcher, path, modifier);
                } else {
                    registerPathToWatcher(modifier, path, watcher);
                }

                task = new WatchFileChangesTask(watcher, path);

                executorService = getCamelContext().getExecutorServiceManager().newSingleThreadExecutor(this,
                        "FileWatcherReloadStrategy");
                executorService.submit(task);
            } catch (IOException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }
    }

    private Object decodeWithSymmetricKey(Exchange exchange, Document encodedDocument) throws Exception {
        SecretKey keyEncryptionKey;
        if (xmlCipherAlgorithm.equals(XMLCipher.TRIPLEDES)) {
            keyEncryptionKey = generateKeyEncryptionKey("DESede");
        } else {
            keyEncryptionKey = generateKeyEncryptionKey("AES");
        }

        Object ret = null;
        try {
            ret = decode(exchange, encodedDocument, keyEncryptionKey, true);
        } catch (org.apache.xml.security.encryption.XMLEncryptionException ex) {
            if (ex.getMessage().equals("encryption.nokey")) {
                 
                ret = decode(exchange, encodedDocument, keyEncryptionKey, false);
            } else {
                throw ex;
            }
        }

         
        try {
            keyEncryptionKey.destroy();
        } catch (javax.security.auth.DestroyFailedException ex) {
            LOG.debug("Error destroying key: {}", ex.getMessage());
        }

        return ret;
    }

    private ShareFileItem[] getFilesFast(GenericFileOperations<ShareFileItem> operations, GenericFile<ShareFileItem> file) {
        String path = file.getAbsoluteFilePath();
        if (path.equals("/") || path.equals("\\")) {
             
            LOG.trace("Using fast exists to update file information in home directory");
            return operations.listFiles();
        } else {
            LOG.trace("Using fast exists to update file information for {}", path);
            return operations.listFiles(path);
        }
    }

    public String dumpStatisticsAsJsonTimeUnitSeconds() {
        ObjectWriter writer = secondsMapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public static void configureCompressions(String names, AbstractFactoryManager factoryManager) {
        if (isBlank(names)) {
            return;
        }
        Set<BuiltinCompressions> builtIn = BuiltinCompressions.VALUES;
        Set<CompressionFactory> registered = BuiltinCompressions.getRegisteredExtensions();
        Set<CompressionFactory> allCompressionFactories = new HashSet<>();
        allCompressionFactories.addAll(builtIn);
        allCompressionFactories.addAll(registered);
        List<NamedFactory<Compression>> avail = (List) NamedFactory.setUpBuiltinFactories(false, allCompressionFactories);
        factoryManager.setCompressionFactories(filter(Compression.class, avail, names.split(",")));
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    protected String resolvePropertyPlaceholders(String str) {
        try {
            if (getCamelContext() != null) {
                return getCamelContext().resolvePropertyPlaceholders(str);
            } else {
                return str;
            }
        } catch (Exception ex) {
            throw RuntimeCamelException.wrapRuntimeCamelException(ex);
        }
    }

    protected void openCircuit(Route route) {
        try {
            lock.lock();
            suspendOrStopConsumer(route.getConsumer());
            state.set(STATE_OPEN);
            openedAt = System.currentTimeMillis();
            this.addHalfOpenTimer(route);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public static byte[] exportPublicKey(PublicKey publicKey, KeyLifecycleManager.KeyFormat format) throws Exception {
        switch (format) {
            case PEM:
                return exportPublicKeyToPEM(publicKey);
            case DER:
            case X509:
                return publicKey.getEncoded();  
            default:
                throw new IllegalArgumentException("Unsupported format for public key: " + format);
        }
    }

    protected Integer doStatusCall() {
        List<StatusRow> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        StatusRow row = new StatusRow();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);
                        JsonObject jo = root.getMap("trace");
                        if (jo != null) {
                            row.enabled = jo.getBoolean("enabled");
                            row.standby = jo.getBoolean("standby");
                            row.counter = jo.getLong("counter");
                            row.queueSize = jo.getLong("queueSize");
                            row.filter = jo.getString("traceFilter");
                            row.pattern = jo.getString("tracePattern");
                        }
                        rows.add(row);
                    }
                });

         
        rows.sort(this::sortStatusRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("AGE").headerAlign(HorizontalAlign.CENTER).with(r -> r.age),
                    new Column().header("STATUS").with(this::getTraceStatus),
                    new Column().header("TOTAL").with(r -> "" + r.counter),
                    new Column().header("QUEUE").with(r -> "" + r.queueSize),
                    new Column().header("FILTER").with(r -> r.filter),
                    new Column().header("PATTERN").with(r -> r.pattern))));
        }

        return 0;
    }

    public InputGuardrailResult validate(UserMessage userMessage) {
        if (userMessage == null || userMessage.singleText() == null) {
            return success();
        }

        String text = userMessage.singleText();
        List<InjectionCategory> detectedCategories = new ArrayList<>();

        for (InjectionPattern pattern : patterns) {
            if (pattern.getPattern().matcher(text).find()) {
                if (!detectedCategories.contains(pattern.getCategory())) {
                    detectedCategories.add(pattern.getCategory());
                }

                 
                if (strict) {
                    return failure(
                            String.format("Potential prompt injection detected: %s pattern. " +
                                          "Please rephrase your request.",
                                    pattern.getCategory()));
                }
            }
        }

         
        if (detectedCategories.size() >= 2) {
            return failure(
                    String.format("Potential prompt injection detected: multiple suspicious patterns (%s). " +
                                  "Please rephrase your request.",
                            detectedCategories));
        }

        return success();
    }

    protected void doDeleteNamespace(Exchange exchange) {
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("Delete a specific namespace require specify a namespace name");
            throw new IllegalArgumentException("Delete a specific namespace require specify a namespace name");
        }

        List<StatusDetails> statusDetails = getEndpoint().getKubernetesClient().namespaces().withName(namespaceName).delete();
        boolean namespaceDeleted = ObjectHelper.isNotEmpty(statusDetails);

        prepareOutboundMessage(exchange, namespaceDeleted);
    }

    private String parseDestinationName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        String shortUri = StringHelper.before(uri, "::");
        final int lastIdx = lastIndexOneOf(uri, shortUri);
        if (lastIdx != -1) {
            return uri.substring(lastIdx + 1);
        } else {
            return null;
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {

        if (remaining == null || remaining.isBlank()) {
            throw new IllegalArgumentException("At least the account name must be specified.");
        }

        final BlobConfiguration config = this.configuration != null ? this.configuration.copy() : new BlobConfiguration();

        final String[] parts = remaining.split("/");

         
        config.setAccountName(parts[0]);

         
        if (parts.length > 1) {
            config.setContainerName(parts[1]);
        }

        final BlobEndpoint endpoint = new BlobEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

        initCredentialConfig(config);
        validateConfigurations(config);

        return endpoint;
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.blob.getBlob");

        if (message.getHeaders().containsKey(BlobConstants.E_TAG)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.blob." + message.getHeader(BlobConstants.E_TAG, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(BlobConstants.BLOB_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    private VolumeSnapshot messageToSnapshot(Message message) {
        VolumeSnapshot volume = message.getBody(VolumeSnapshot.class);
        if (volume == null) {
            Map headers = message.getHeaders();
            VolumeSnapshotBuilder builder = Builders.volumeSnapshot();

            final String name = message.getHeader(OpenstackConstants.NAME, String.class);
            StringHelper.notEmpty(name, "Name");
            builder.name(name);

            if (headers.containsKey(OpenstackConstants.DESCRIPTION)) {
                builder.description(message.getHeader(OpenstackConstants.DESCRIPTION, String.class));
            }

            if (headers.containsKey(CinderConstants.VOLUME_ID)) {
                builder.volume(message.getHeader(CinderConstants.VOLUME_ID, String.class));
            }

            if (headers.containsKey(CinderConstants.FORCE)) {
                builder.force(message.getHeader(CinderConstants.FORCE, Boolean.class));
            }

            volume = builder.build();
        }

        return volume;
    }

    private void createBucket(Exchange exchange, ClientConfigurations clientConfigurations) throws ObsException {
        CreateBucketRequest request = null;

         
        Object exchangeBody = exchange.getMessage().getBody();
        if (exchangeBody instanceof CreateBucketRequest) {
            request = (CreateBucketRequest) exchangeBody;
        } else if (exchangeBody instanceof String) {
            String strBody = (String) exchangeBody;
            try {
                request = new ObjectMapper().readValue(strBody, CreateBucketRequest.class);
            } catch (JsonProcessingException e) {
                LOG.warn(
                        "String request body must be a valid JSON representation of a CreateBucketRequest. Attempting to create a bucket from endpoint parameters");
            }
        }

         
        if (request == null) {
             
            if (ObjectHelper.isEmpty(clientConfigurations.getBucketName())) {
                LOG.error("No bucket name given");
                throw new IllegalArgumentException("Bucket name is mandatory to create bucket");
            }

             
            if (ObjectHelper.isEmpty(clientConfigurations.getBucketLocation())) {
                LOG.warn("No bucket location given, defaulting to '{}'", OBSConstants.DEFAULT_LOCATION);
                clientConfigurations.setBucketLocation(OBSConstants.DEFAULT_LOCATION);
            }
             
            OBSRegion.checkValidRegion(clientConfigurations.getBucketLocation());

            request = new CreateBucketRequest(clientConfigurations.getBucketName(), clientConfigurations.getBucketLocation());
        }

         
        ObsBucket response = obsClient.createBucket(request);
        exchange.getMessage().setBody(gson.toJson(response));
    }

    default Map<String, List<String>> determineHeaders(final Exchange exchange) {
        final Message inboundMessage = exchange.getIn();

        final Map<String, Object> headers = inboundMessage.getHeaders();

        final Map<String, List<String>> answer = new HashMap<>();
        for (final String headerName : headers.keySet()) {
            final String headerNameLowercase = headerName.toLowerCase(Locale.US);
            if (headerNameLowercase.startsWith("sforce") || headerNameLowercase.startsWith("x-sfdc")) {
                final Object headerValue = inboundMessage.getHeader(headerName);

                if (headerValue instanceof String) {
                    answer.put(headerName, Collections.singletonList((String) headerValue));
                } else if (headerValue instanceof String[]) {
                    answer.put(headerName, Arrays.asList((String[]) headerValue));
                } else if (headerValue instanceof Collection) {
                    Collection<?> collection = (Collection<?>) headerValue;
                    answer.put(headerName, collection.stream().map(String.class::cast).collect(Collectors.toList()));
                } else {
                    answer.put(headerName, Collections.singletonList(String.valueOf(headerValue)));
                }
            }
        }
        return answer;
    }

    public ManagedStepMBean getManagedStep(String id) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Processor processor = camelContext.getProcessor(id);
        ProcessorDefinition<?> def
                = camelContext.getCamelContextExtension().getContextPlugin(Model.class).getProcessorDefinition(id);

         
        if (def != null) {
            try {
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy()
                        .getObjectNameForStep(camelContext, processor, def);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedStepMBean.class);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    private void generateUploadUrl(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException {
        GenerateUploadUrlResponse response = null;
        if (getConfiguration().isPojoRequest()) {
            GenerateUploadUrlRequest request = exchange.getIn().getMandatoryBody(GenerateUploadUrlRequest.class);
            response = client.generateUploadUrl(request);
        } else {
            LocationName locationName = LocationName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation());
            GenerateUploadUrlRequest request = GenerateUploadUrlRequest.newBuilder().setParent(locationName.toString())
                    .build();
            response = client.generateUploadUrl(request);
        }
        Message message = getMessageForResponse(exchange);
        message.setHeader(GoogleCloudFunctionsConstants.RESPONSE_OBJECT, response);
        message.setBody(response.getUploadUrl());
    }

    public InputStream loadResourceAsStream(String uri) {
        resourceResolverListeners.forEach(l -> l.onLoadResourceAsStream(uri));

        InputStream answer = null;
        try {
            answer = super.loadResourceAsStream(uri);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(uri);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(uri, ".", uri);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && uri.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = super.loadResourceAsStream(uri);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    public static JsonObject asJsonObject(EipModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        obj.put("abstract", model.isAbstractModel());
        obj.put("input", model.isInput());
        obj.put("output", model.isOutput());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("model", obj);
        wrapper.put("properties", asJsonObject(model.getOptions()));
        if (!model.getExchangeProperties().isEmpty()) {
            wrapper.put("exchangeProperties", asJsonObject(model.getExchangeProperties()));
        }
        return wrapper;
    }

    private boolean isIncludedHeader(String key) {
        String[] parts = filter.split(",");
        for (String pattern : parts) {
            if (pattern.startsWith("--")) {
                continue;
            }
            if (pattern.startsWith("header:") || pattern.startsWith("+header:")) {
                pattern = StringHelper.after(pattern, "header:");
            }
            if (PatternHelper.matchPattern(key, pattern)) {
                return true;
            }
        }
        return false;
    }

    private boolean doSend(Exchange exchange, AsyncCallback callback) {
        if (isRunAllowed()) {
            getAsyncProcessor().process(exchange, doneSync -> {
                if (exchange.getException() != null) {
                    getExceptionHandler().handleException("Error processing exchange", exchange, exchange.getException());
                }
                callback.done(doneSync);
            });
            return false;
        } else {
            LOG.warn("Consumer not ready to process exchanges. The exchange {} will be discarded", exchange);
            callback.done(true);
            return true;
        }
    }

    protected SubmitMulti[] createSubmitMulti(Exchange exchange) throws SmppException {
        Message message = exchange.getIn();
        byte[][] segments = splitBody(message);
        SubmitMulti template = createSubmitMultiTemplate(exchange);

         
        ESMClass esmClass = message.getHeader(SmppConstants.ESM_CLASS, ESMClass.class);
        if (esmClass != null) {
            template.setEsmClass(esmClass.value());
        } else if (segments.length > 1) {
             
            template.setEsmClass(new ESMClass(MessageMode.DEFAULT, MessageType.DEFAULT, GSMSpecificFeature.UDHI).value());
        }

        SubmitMulti[] submitMulties = new SubmitMulti[segments.length];
        for (int i = 0; i < segments.length; i++) {
            SubmitMulti submitMulti = SmppUtils.copySubmitMulti(template);
            submitMulti.setShortMessage(segments[i]);
            submitMulties[i] = submitMulti;
        }

        setRegisterDeliveryReceiptFlag(submitMulties, message);
        return submitMulties;
    }

                public void onComplete(Exchange exchange) {
                     
                    Boolean close;
                    if (ExchangeHelper.isOutCapable(exchange)) {
                        close = exchange.getOut().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    } else {
                        close = exchange.getIn().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    }

                     
                    boolean disconnect = getConfiguration().isDisconnect();
                    if (close != null) {
                        disconnect = close;
                    }

                    if (disconnect) {
                        LOG.trace("Closing channel {} as routing the Exchange is done", channel);
                        NettyHelper.close(channel);
                    }

                    releaseChannel(channelFuture);
                }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.syslog.SyslogMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toString((org.apache.camel.component.syslog.SyslogMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.camel.component.syslog.SyslogMessage.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.syslog.SyslogConverter.toSyslogMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpServerConfigurationProperties properties) {
        String authPropertiesFileName = properties.getBasicPropertiesFile();
        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : DEFAULT_REALM;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationConfig.AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                return BasicAuthHandler.create(authenticationProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(
                vertx -> PropertyFileAuthentication.create(vertx, authPropertiesFileName));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    protected void openCircuit(Route route) {
        try {
            lock.lock();
            suspendOrStopConsumer(route.getConsumer());
            state.set(STATE_OPEN);
            openedAt = System.currentTimeMillis();
            this.addHalfOpenTimer(route);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public static <B extends AwsClientBuilder<B, C> & SdkAsyncClientBuilder<B, C>, C extends SdkClient> C buildAsyncClient(
            AwsCommonConfiguration config,
            Supplier<B> builderSupplier,
            Consumer<B> serviceSpecificConfig) {

        B clientBuilder = builderSupplier.get();
        NettyNioAsyncHttpClient.Builder httpClientBuilder = null;
        boolean httpClientConfigured = false;

         
        if (ObjectHelper.isNotEmpty(config.getProxyHost())
                && ObjectHelper.isNotEmpty(config.getProxyPort())) {
            LOG.trace("Configuring async proxy: {}:{}", config.getProxyHost(), config.getProxyPort());
            software.amazon.awssdk.http.nio.netty.ProxyConfiguration proxyConfig
                    = software.amazon.awssdk.http.nio.netty.ProxyConfiguration.builder()
                            .scheme(config.getProxyProtocol().toString())
                            .host(config.getProxyHost())
                            .port(config.getProxyPort())
                            .build();
            httpClientBuilder = NettyNioAsyncHttpClient.builder().proxyConfiguration(proxyConfig);
            httpClientConfigured = true;
        }

         
        AwsCredentialsProvider credentialsProvider = resolveCredentialsProvider(config);
        if (credentialsProvider != null) {
            clientBuilder.credentialsProvider(credentialsProvider);
        }

         
        if (httpClientConfigured) {
            clientBuilder.httpClientBuilder(httpClientBuilder);
        }

         
        if (ObjectHelper.isNotEmpty(config.getRegion())) {
            clientBuilder.region(Region.of(config.getRegion()));
        }

         
        if (config.isOverrideEndpoint() && ObjectHelper.isNotEmpty(config.getUriEndpointOverride())) {
            clientBuilder.endpointOverride(URI.create(config.getUriEndpointOverride()));
        }

         
        if (config.isTrustAllCertificates()) {
            if (httpClientBuilder == null) {
                httpClientBuilder = NettyNioAsyncHttpClient.builder();
            }
            SdkAsyncHttpClient asyncHttpClient = httpClientBuilder.buildWithDefaults(
                    AttributeMap.builder()
                            .put(SdkHttpConfigurationOption.TRUST_ALL_CERTIFICATES, Boolean.TRUE)
                            .build());
            clientBuilder.httpClient(asyncHttpClient);
            clientBuilder.httpClientBuilder(null);
        }

         
        if (serviceSpecificConfig != null) {
            serviceSpecificConfig.accept(clientBuilder);
        }

        return clientBuilder.build();
    }

    private void handleNotFound(EndpointValidationResult result, String value, String name, List<String> enums) {
        result.addInvalidEnum(name, value);
        result.addInvalidEnumChoices(name, enums.toArray(new String[0]));
        if (suggestionStrategy != null) {
            Set<String> names = new LinkedHashSet<>(enums);
            String[] suggestions = suggestionStrategy.suggestEndpointOptions(names, value);
            if (suggestions != null) {
                result.addInvalidEnumSuggestions(name, suggestions);
            }
        }
    }

    public InputGuardrailResult validate(UserMessage userMessage) {
        if (userMessage == null || userMessage.singleText() == null) {
            return fatal("User message cannot be null or empty");
        }

        String text = userMessage.singleText();
        int length = text.length();

        if (length < minChars) {
            return failure(
                    String.format("Input too short: %d characters (minimum: %d)", length, minChars));
        }

        if (length > maxChars) {
            return failure(
                    String.format("Input too long: %d characters (maximum: %d)", length, maxChars));
        }

        return success();
    }

    private void listObjects(MinioClient minioClient, Exchange exchange) throws InvalidPayloadException {

        if (getConfiguration().isPojoRequest()) {
            ListObjectsArgs.Builder payload = exchange.getIn().getMandatoryBody(ListObjectsArgs.Builder.class);
            if (isNotEmpty(payload)) {
                Iterable<Result<Item>> objectList = minioClient.listObjects(payload.build());
                Message message = getMessageForResponse(exchange);
                message.setBody(objectList);
            }
        } else {
            final String bucketName = determineBucketName(exchange);

            Iterable<Result<Item>> objectList = minioClient.listObjects(ListObjectsArgs.builder()
                    .bucket(bucketName)
                    .build());

            Message message = getMessageForResponse(exchange);
            message.setBody(objectList);
        }
    }

    public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
        MetricsRoutePolicy answer = new MetricsRoutePolicy();
        answer.setMetricsRegistry(getMetricsRegistry());
        answer.setUseJmx(isUseJmx());
        answer.setJmxDomain(getJmxDomain());
        answer.setPrettyPrint(isPrettyPrint());
        answer.setRateUnit(getRateUnit());
        answer.setDurationUnit(getDurationUnit());
        if (namePattern != null) {
            answer.setNamePattern(namePattern);
        }
        return answer;
    }

    protected void doDeleteTag(String operation) throws GitAPIException {
        if (ObjectHelper.isEmpty(endpoint.getTagName())) {
            throw new IllegalArgumentException("Tag Name must be specified to execute " + operation);
        }
        try {
            git.tagDelete().setTags(endpoint.getTagName()).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    public void remove(CamelContext camelContext, String key, Exchange exchange) {
        DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
        if (optimistic) {
            LOG.trace("Removing an exchange with ID {} for key {} in an optimistic manner.", exchange.getExchangeId(), key);
            if (!cache.remove(key, holder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#remove removed no Exchanges, while it's expected to remove one.",
                        key);
                throw new OptimisticLockingException();
            }
            LOG.trace("Removed an exchange with ID {} for key {} in an optimistic manner.", exchange.getExchangeId(), key);
            if (useRecovery) {
                LOG.trace("Putting an exchange with ID {} for key {} into a recoverable storage in an optimistic manner.",
                        exchange.getExchangeId(), key);
                persistedCache.put(exchange.getExchangeId(), holder);
                LOG.trace("Put an exchange with ID {} for key {} into a recoverable storage in an optimistic manner.",
                        exchange.getExchangeId(), key);
            }
        } else {
            if (useRecovery) {
                LOG.trace("Removing an exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
                 
                 
                 
                TransactionOptions tOpts = new TransactionOptions();

                tOpts.setTransactionType(TransactionOptions.TransactionType.ONE_PHASE);
                TransactionContext tCtx = hazelcastInstance.newTransactionContext(tOpts);

                try {
                    tCtx.beginTransaction();

                    TransactionalMap<String, DefaultExchangeHolder> tCache = tCtx.getMap(cache.getName());
                    TransactionalMap<String, DefaultExchangeHolder> tPersistentCache = tCtx.getMap(persistedCache.getName());

                    DefaultExchangeHolder removedHolder = tCache.remove(key);
                    LOG.trace("Putting an exchange with ID {} for key {} into a recoverable storage in a thread-safe manner.",
                            exchange.getExchangeId(), key);
                    tPersistentCache.put(exchange.getExchangeId(), removedHolder);

                    tCtx.commitTransaction();
                    LOG.trace("Removed an exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(),
                            key);
                    LOG.trace("Put an exchange with ID {} for key {} into a recoverable storage in a thread-safe manner.",
                            exchange.getExchangeId(), key);
                } catch (Exception exception) {
                    tCtx.rollbackTransaction();

                    final String msg = String.format(
                            "Transaction with ID %s was rolled back for remove operation with a key %s and an Exchange ID %s.",
                            tCtx.getTxnId(), key, exchange.getExchangeId());
                    LOG.warn(msg, exception);
                    throw new RuntimeCamelException(msg, exception);
                }
            } else {
                cache.remove(key);
            }
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        if (remaining == null || remaining.isBlank()) {
            throw new IllegalArgumentException("A queue or topic name must be specified.");
        }

        final ServiceBusConfiguration configuration
                = this.configuration != null ? this.configuration.copy() : new ServiceBusConfiguration();

         
        configuration.setTopicOrQueueName(remaining);

        final ServiceBusEndpoint endpoint = new ServiceBusEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

         
        if (endpoint.getConfiguration().getTokenCredential() == null) {
            if (endpoint.getConfiguration().getCredentialType() == null) {
                endpoint.getConfiguration().setCredentialType(CredentialType.CONNECTION_STRING);
            }
        } else {
            boolean azure = endpoint.getConfiguration().getTokenCredential() instanceof DefaultAzureCredential;
            endpoint.getConfiguration()
                    .setCredentialType(azure ? CredentialType.AZURE_IDENTITY : CredentialType.TOKEN_CREDENTIAL);
        }

        return endpoint;
    }

    private void processUpsertSobject(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        String sObjectExtIdValue;
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
             
            sObjectBase.clearBaseFields();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, IGNORE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.upsertSObject(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                getRequestStream(exchange), new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    private void processCreateQueryJob(Exchange exchange, AsyncCallback callback)
            throws InvalidPayloadException {
        QueryJob job = exchange.getIn().getMandatoryBody(QueryJob.class);
        bulkClient.createQueryJob(job, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobResponseCallback() {
                    @Override
                    public void onResponse(
                            QueryJob job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    public Optional<Object> newInstance(String key) {
        maybeDownload(key);

        if (export && skip(key)) {
            return Optional.empty();
        }

        Optional<Object> answer = super.newInstance(key);
        if (answer.isEmpty()) {
             
            final FactoryFinder finder
                    = camelContext.getCamelContextExtension().getFactoryFinder(PeriodTaskResolver.RESOURCE_PATH);
            Object obj = ResolverHelper.resolveService(camelContext, finder, key, Object.class).orElse(null);
            return Optional.ofNullable(obj);
        }
        return answer;
    }

    public IamClient initClient() {
        if (iamClient != null) {
            return iamClient;
        }

         
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getAccessKey())) {
            throw new IllegalArgumentException("Authentication parameter 'access key (AK)' not found");
        }
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getSecretKey())) {
            throw new IllegalArgumentException("Authentication parameter 'secret key (SK)' not found");
        }

         
        GlobalCredentials auth = new GlobalCredentials()
                .withAk(getServiceKeys() != null
                        ? getServiceKeys().getAccessKey()
                        : getAccessKey())
                .withSk(getServiceKeys() != null
                        ? getServiceKeys().getSecretKey()
                        : getSecretKey());

         
        HttpConfig httpConfig = HttpConfig.getDefaultHttpConfig();
        httpConfig.withIgnoreSSLVerification(isIgnoreSslVerification());
        if (ObjectHelper.isNotEmpty(getProxyHost())
                && ObjectHelper.isNotEmpty(getProxyPort())) {
            httpConfig.withProxyHost(getProxyHost())
                    .withProxyPort(getProxyPort());

            if (ObjectHelper.isNotEmpty(getProxyUser())) {
                httpConfig.withProxyUsername(getProxyUser());
                if (ObjectHelper.isNotEmpty(getProxyPassword())) {
                    httpConfig.withProxyPassword(getProxyPassword());
                }
            }
        }

         
        if (ObjectHelper.isNotEmpty(getRegion())) {
            return IamClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withRegion(IamRegion.valueOf(getRegion()))
                    .build();
        } else {
            throw new IllegalArgumentException("Region not found");
        }
    }

    public XMLEventReader createXMLEventReader(InputStream in, Exchange exchange) throws XMLStreamException {
        XMLInputFactory factory = getInputFactory();
        try {
            String charsetName = ExchangeHelper.getCharsetName(exchange, false);
            if (charsetName == null) {
                return factory.createXMLEventReader(IOHelper.buffered(in));
            } else {
                return factory.createXMLEventReader(IOHelper.buffered(in), charsetName);
            }
        } finally {
            returnXMLInputFactory(factory);
        }
    }

    public void performList(final Exchange exchange, AsyncCallback callback) {
        Message message = exchange.getMessage();
        Map<String, Object> headers = message.getHeaders();
        String subscribeChannel = (String) headers.getOrDefault(CONTROL_SUBSCRIBE_CHANNEL, configuration.getSubscribeChannel());
        try {
            String filters = dynamicRouterControlService.getSubscriptionsForChannel(subscribeChannel);
            message.setBody(filters, String.class);
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
            callback.done(false);
        }
    }

    public static Predicate contains(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceContains(exchange.getContext().getTypeConverter(), leftValue, rightValue, false);
            }

            protected String getOperationText() {
                return "contains";
            }
        };
    }

    public ResultBuilder error(ThrowingConsumer<ResultBuilder, Exception> consumer) {
        try {
            consumer.accept(this);
        } catch (NoSuchOptionException e) {
            error(ResultErrorBuilder.withMissingOption(e.getOptionName()).build());
        } catch (IllegalOptionException e) {
            error(ResultErrorBuilder.withIllegalOption(e.getOptionName(), e.getOptionValue()).build());
        } catch (Exception e) {
            error(ResultErrorBuilder.withException(e).build());
        }

        return this;
    }

    private void retainClusterView() {
        lock.lock();
        try {
            clusterView = clusterService.getView(namespace);
            clusterView.addEventListener(leadershipEventListener);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public JobKey retrieveJobKey(Action action, ScheduledRouteDetails scheduledRouteDetails) {
        JobKey result = null;

        if (action == Action.START) {
            result = scheduledRouteDetails.getStartJobKey();
        } else if (action == Action.STOP) {
            result = scheduledRouteDetails.getStopJobKey();
        } else if (action == Action.SUSPEND) {
            result = scheduledRouteDetails.getSuspendJobKey();
        } else if (action == Action.RESUME) {
            result = scheduledRouteDetails.getResumeJobKey();
        }

        return result;
    }

    public void forceDisconnect() throws GenericFileOperationFailedException {
        lock.lock();
        try {
            if (session != null) {
                session.disconnect();
            }
            if (channel != null) {
                channel.disconnect();
            }
        } finally {
             
            session = null;
            channel = null;
            lock.unlock();
        }
    }

    public final T getObject() throws Exception {
        if (this.isSingleton()) {
            if (instance == null) {
                instance = createInstanceInternal();
            }

            return instance;
        } else {
            return createInstanceInternal();
        }
    }

        public void onTopic(String channel, IRCUser user, String topic) {
            if (configuration.isOnTopic()) {
                Exchange exchange = createOnTopicExchange(channel, user, topic);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

        public AnnotationBuilder withDefaultValue(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual() && !node.isNumber() && !node.isBoolean()) {
                return this;
            }

            return withDefaultValue(node.asText());
        }

    private FTPFile[] getFtpFiles(String dir) {
        FTPFile[] files = null;
        try {
            LOG.trace("Polling directory: {}", dir);
            if (isUseList()) {
                files = listFiles(dir);
            } else {
                files = pollNamedFile();
            }
        } catch (GenericFileOperationFailedException e) {
            if (ignoreCannotRetrieveFile(null, null, e)) {
                LOG.debug("Cannot list files in directory {} due directory does not exist or file permission error.", dir);
            } else {
                throw e;
            }
        }
        return files;
    }

    private void setupEndpointStrategies() {
        Map<String, EndpointStrategy> endpointStrategies
                = getContext().getRegistry().findByTypeWithName(EndpointStrategy.class);
        if (endpointStrategies != null && !endpointStrategies.isEmpty()) {
            for (Entry<String, EndpointStrategy> entry : endpointStrategies.entrySet()) {
                EndpointStrategy strategy = entry.getValue();
                LOG.info("Using custom EndpointStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                getContext().getCamelContextExtension().registerEndpointCallback(strategy);
            }
        }
    }

    private String calculateRouteCoverage(ManagedRouteGroupMBean mrg, boolean percent) {
        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);

        Collection<String> ids = new ArrayList<>();
        for (String id : mrg.getGroupIds()) {
            ManagedRouteMBean mrb = mcc.getManagedRoute(id);
            try {
                ids.addAll(mrb.processorIds());
            } catch (Exception e) {
                return null;
            }
        }

        int total = ids.size();
        int covered = 0;

        for (String id : ids) {
            ManagedProcessorMBean mp = mcc.getManagedProcessor(id);
            if (mp != null) {
                if (mp.getExchangesTotal() > 0) {
                    covered++;
                }
            }
        }

        if (percent) {
            double p;
            if (total > 0) {
                p = ((double) covered / total) * 100;
            } else {
                p = 0;
            }
            String f = String.format("%.0f", p);
            return covered + "/" + total + " (" + f + "%)";
        } else {
            return covered + "/" + total;
        }
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    private ExecStartCmd executeExecStartRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Exec Start Request");

        String execId = DockerHelper.getProperty(DockerConstants.DOCKER_EXEC_ID, configuration, message, String.class);

        ObjectHelper.notNull(execId, "Exec ID must be specified");

        ExecStartCmd execStartCmd = client.execStartCmd(execId);

        Boolean detach = DockerHelper.getProperty(DockerConstants.DOCKER_DETACH, configuration, message, Boolean.class);

        if (detach != null) {
            execStartCmd.withDetach(detach);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            execStartCmd.withTty(tty);
        }

        return execStartCmd;

    }

    public PollingConsumer createPollingConsumer() throws Exception {
        ObjectHelper.notNull(operations, PARAM_OPERATIONS);
        ObjectHelper.notNull(file, PARAM_FILE);

        if (maxMessagesPerPoll > 1) {
            throw new IllegalArgumentException(
                    "The option maxMessagesPerPoll is not supported for polling consumer (such as when using poll or pollEnrich EIP)");
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Creating GenericFilePollingConsumer with queueSize: {} blockWhenFull: {} blockTimeout: {}",
                    getPollingConsumerQueueSize(), isPollingConsumerBlockWhenFull(),
                    getPollingConsumerBlockTimeout());
        }
        GenericFilePollingConsumer result = new GenericFilePollingConsumer(this);
         
         
        result.setBlockWhenFull(isPollingConsumerBlockWhenFull());
        result.setBlockTimeout(getPollingConsumerBlockTimeout());

        return result;
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    private String determineBucketName(Exchange exchange) {
        String bucketName = exchange.getMessage().getHeader(GoogleCloudStorageConstants.OVERRIDE_BUCKET_NAME, String.class);
        if (ObjectHelper.isEmpty(bucketName)) {
            bucketName = getConfiguration().getBucketName();
        }
        if (bucketName == null) {
            throw new IllegalArgumentException("Bucket name is missing or not configured.");
        }
        return bucketName;
    }

    private void processGetJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        String jobId;
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public Gmail makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Gmail client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Gmail.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Gmail client.", e);
        }
    }

    public StaticServiceCallServiceDiscoveryConfiguration servers(String servers) {
        if (ObjectHelper.isNotEmpty(servers)) {
            String[] parts = servers.split(",");

            if (this.servers == null) {
                this.servers = new ArrayList<>();
            }

            this.servers.addAll(Arrays.asList(parts));
        }

        return this;
    }

    public void process(Exchange exchange) throws Exception {
        Sqs2Operations operation = determineOperation(exchange);
        if (ObjectHelper.isEmpty(operation)) {
            processSingleMessage(exchange);
        } else {
            switch (operation) {
                case sendBatchMessage:
                    sendBatchMessage(getClient(), exchange);
                    break;
                case deleteMessage:
                    deleteMessage(getClient(), exchange);
                    break;
                case listQueues:
                    listQueues(getClient(), exchange);
                    break;
                case purgeQueue:
                    purgeQueue(getClient(), exchange);
                    break;
                case deleteQueue:
                    deleteQueue(getClient(), exchange);
                    break;
                default:
                    throw new IllegalArgumentException("Unsupported operation");
            }
        }
    }

    protected Object doInvokeMethod(Map<String, Object> properties) throws RuntimeCamelException {
        AbstractGoogleClientRequest<?> request = (AbstractGoogleClientRequest) super.doInvokeMethod(properties);
        try {
            BeanIntrospection beanIntrospection
                    = PluginHelper.getBeanIntrospection(getEndpoint().getCamelContext());
            for (Entry<String, Object> p : properties.entrySet()) {
                beanIntrospection.setProperty(getEndpoint().getCamelContext(), request, p.getKey(), p.getValue());
            }
            return request.execute();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public boolean hasNext() {
        try {
            if (tarInputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = tarInputStream.getCurrentEntry() != null && tarInputStream.available() > 0;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    tarInputStream.close();
                    availableDataInCurrentEntry = false;
                } else {
                    availableDataInCurrentEntry = true;
                }
                if (first && parent == null) {
                    throw new IllegalStateException("Unable to untar the file, it may be corrupted.");
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.storage.downloadTo");

        if (message.getHeaders().containsKey(GoogleCloudStorageConstants.BUCKET_NAME)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.storage.bucket." + message.getHeader(GoogleCloudStorageConstants.BUCKET_NAME, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getHeader(GoogleCloudStorageConstants.OBJECT_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
    }

    public String getLabel() {
        if (endpointUriToString == null) {
            String value = null;
            try {
                value = getEndpointUri();
            } catch (RuntimeException e) {
                 
            }
             
            endpointUriToString = URISupport.sanitizeUri(value);
        }

        String uri = endpointUriToString;
        return uri != null ? uri : "no uri supplied";
    }

private int jjMoveStringLiteralDfa5_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(3, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0);
      return 5;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x8L) != 0L)
            return jjStopAtPos(5, 3);
         break;
      default :
         break;
   }
   return jjStartNfa_0(4, active0);
}

    public boolean checkAfterSendProperties(Exchange exchange, Socket socket, Logger log) {
        final String logMessageFormat = "Exchange property {} = {} - {} connection";
        boolean answer = true;

        final boolean resetAfterSend
                = exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND, false, boolean.class);
        if (resetAfterSend) {
            log.warn(logMessageFormat, MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND,
                    exchange.getProperty(MllpConstants.MLLP_RESET_CONNECTION_AFTER_SEND), "resetting");
            doConnectionClose(socket, true, log);
            answer = false;
        } else {
            final boolean closeAfterSend
                    = exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND, false, boolean.class);
            if (closeAfterSend) {
                log.warn(logMessageFormat, MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND,
                        exchange.getProperty(MllpConstants.MLLP_CLOSE_CONNECTION_AFTER_SEND), "closing");
                doConnectionClose(socket, false, log);
                answer = false;
            }
        }

        return answer;
    }

    public TabularData extendedInformation() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.endpointsUtilizationTabularType());

             
            CompositeType ct = CamelOpenMBeanTypes.endpointsUtilizationCompositeType();
            String url = getDestination();
            long hits = getProcessor().getCounter();

            CompositeData data = new CompositeDataSupport(ct, new String[] { "url", "hits" }, new Object[] { url, hits });
            answer.put(data);
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.blob.getBlob");

        if (message.getHeaders().containsKey(BlobConstants.E_TAG)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.blob." + message.getHeader(BlobConstants.E_TAG, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(BlobConstants.BLOB_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    protected AbstractGitHubProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);
        this.endpoint = endpoint;

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_REPOSITORY_SERVICE);
        if (service != null) {
            repositoryService = (RepositoryService) service;
        } else {
            repositoryService = new RepositoryService();
        }
        initService(repositoryService);
        repository = repositoryService.getRepository(endpoint.getRepoOwner(), endpoint.getRepoName());
    }

    private JsonObject asJsonObject(BeanPojoModel model) {
        JsonObject jo = new JsonObject();
         
        jo.put("kind", "bean");
        jo.put("name", model.getName());
        jo.put("javaType", model.getClassName());
        if (model.getInterfaceName() != null) {
            jo.put("interfaceType", model.getInterfaceName());
        }
        jo.put("title", asTitle(model.getName()));
        if (model.getDescription() != null) {
            jo.put("description", model.getDescription());
        }
        jo.put("deprecated", model.isDeprecated());
        jo.put("groupId", project.getGroupId());
        jo.put("artifactId", project.getArtifactId());
        jo.put("version", project.getVersion());

        if (!model.getOptions().isEmpty()) {
            JsonObject options = JsonMapper.asJsonObject(model.getOptions());
            jo.put("properties", options);
        }

        JsonObject root = new JsonObject();
        root.put("bean", jo);
        return root;
    }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    private void addRelevantProjectDependenciesToClasspath(List<URL> path, boolean testClasspathOnly)
            throws MojoExecutionException {
        try {
            getLog().debug("Project Dependencies will be included.");

            if (testClasspathOnly) {
                URL testClasses = new File(project.getBuild().getTestOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + testClasses);
                }
                path.add(testClasses);
            } else {
                URL mainClasses = new File(project.getBuild().getOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + mainClasses);
                }
                path.add(mainClasses);
            }

            Set<Artifact> dependencies = project.getArtifacts();

             
             
            dependencies.addAll(getAllNonTestScopedDependencies());

            for (Artifact classPathElement : dependencies) {
                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding project dependency artifact: " + classPathElement.getArtifactId()
                                   + " to classpath");
                }
                File file = classPathElement.getFile();
                if (file != null) {
                    path.add(file.toURI().toURL());
                }
            }

        } catch (MalformedURLException e) {
            throw new MojoExecutionException("Error during setting up classpath", e);
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    public FluentProducerTemplate withHeaders(Map<String, Object> headers) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException("Cannot use both withHeaders and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.headers;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.headers = map;
        }
        map.putAll(headers);
        return clone;
    }

    public String chat(AiAgentBody<?> aiAgentBody, ToolProvider toolProvider) {
        AiAgentWithMemoryService agentService = createAiAgentService(toolProvider);

        String userMessage = aiAgentBody.getUserMessage();
        Object memoryId = aiAgentBody.getMemoryId();
        String systemMessage = aiAgentBody.getSystemMessage();
        Content content = aiAgentBody.getContent();

        if (content != null) {
             
            return systemMessage != null
                    ? agentService.chat(memoryId, userMessage, content, systemMessage)
                    : agentService.chat(memoryId, userMessage, content);
        } else {
             
            return systemMessage != null
                    ? agentService.chat(memoryId, userMessage, systemMessage)
                    : agentService.chat(memoryId, userMessage);
        }
    }

    private RedeliveryPolicy resolveRedeliveryPolicy(TransactionErrorHandlerDefinition definition, CamelContext camelContext) {
        RedeliveryPolicy answer = null;
        RedeliveryPolicyDefinition def = definition.getRedeliveryPolicy();
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
             
            def = lookupByNameAndType(definition.getRedeliveryPolicyRef(), RedeliveryPolicyDefinition.class);
        }
        if (def != null) {
            answer = ErrorHandlerReifier.createRedeliveryPolicy(def, camelContext, null);
        }
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
            answer = mandatoryLookup(definition.getRedeliveryPolicyRef(), RedeliveryPolicy.class);
        }
        if (answer == null) {
            answer = RedeliveryPolicy.DEFAULT_POLICY;
        }
        return answer;
    }

    public void pre(SpanAdapter span, Exchange exchange, Endpoint endpoint) {
        super.pre(span, exchange, endpoint);
        span.setTag(TagConstants.DB_SYSTEM, CASSANDRA_DB_TYPE);
        URI uri = URI.create(endpoint.getEndpointUri());
        if (uri.getPath() != null && !uri.getPath().isEmpty()) {
             
            span.setTag(TagConstants.DB_NAME, uri.getPath().substring(1));
        }

        String cql = exchange.getIn().getHeader(CAMEL_CQL_QUERY, String.class);
        if (cql != null) {
            span.setTag(TagConstants.DB_STATEMENT, cql);
        } else {
            Map<String, String> queryParameters = toQueryParameters(endpoint.getEndpointUri());
            if (queryParameters.containsKey("cql")) {
                span.setTag(TagConstants.DB_STATEMENT, queryParameters.get("cql"));
            }
        }
    }

    private void insertMeasurement(Exchange exchange, String orgName, String bucketName, WritePrecision writePrecision)
            throws InvalidPayloadException {
        Measurement measurement = exchange.getIn().getMandatoryBody(Measurement.class);
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Writing measurement {}", measurement);
            }
            writeApi.writeMeasurement(bucketName, orgName, writePrecision, measurement.getInfluxMeasurement());
        } catch (Exception ex) {
            exchange.setException(new CamelInfluxDb2Exception(ex));
        }
    }

    public static List<MethodInfo> methods(IndexView view, ClassInfo type, Predicate<MethodInfo> filter) {
        List<MethodInfo> answer = new ArrayList<>();

        for (ClassInfo current = type; current != null;) {
            for (MethodInfo methodInfo : current.methods()) {
                if (filter.test(methodInfo)) {
                    answer.add(methodInfo);
                }
            }

            Type superType = current.superClassType();
            if (superType == null) {
                break;
            }

            current = view.getClassByName(superType.name());
        }

        return answer;
    }

    public String dumpLatestMessageHistoryAsJSon() {
        List<BacklogTracerEventMessage> events = dumpLatestMessageHistory();

        JsonObject root = new JsonObject();
        JsonArray arr = new JsonArray();
        root.put("traces", arr);
        for (BacklogTracerEventMessage event : events) {
            arr.add(event.asJSon());
        }
        return Jsoner.prettyPrint(root.toJson());
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.datalake.consume");

        if (message.getHeaders().containsKey(DataLakeConstants.ARCHIVE_STATUS)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.datalake." + message.getHeader(DataLakeConstants.ARCHIVE_STATUS, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(DataLakeConstants.E_TAG, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    protected void insert(
            final CamelContext camelContext, final String correlationId, final Exchange exchange, String repositoryName,
            final Long version, final boolean completed)
            throws Exception {
         
        int totalParameterIndex = 2;
        StringBuilder queryBuilder = new StringBuilder(256)
                .append("INSERT INTO ").append(repositoryName)
                .append('(')
                .append(EXCHANGE).append(", ")
                .append(ID);

        if (isStoreBodyAsText()) {
            queryBuilder.append(", ").append(BODY);
            totalParameterIndex++;
        }

        if (hasHeadersToStoreAsText()) {
            for (String headerName : getHeadersToStoreAsText()) {
                queryBuilder.append(", ").append(headerName);
                totalParameterIndex++;
            }
        }

        queryBuilder.append(") VALUES (");

        queryBuilder.append("?, ".repeat(Math.max(0, totalParameterIndex - 1)));
        queryBuilder.append("?)");

        queryBuilder.append(" ON CONFLICT DO NOTHING");

        String sql = queryBuilder.toString();

        int updateCount = insertHelper(camelContext, correlationId, exchange, sql, 1L, completed);
        if (updateCount == 0 && getRepositoryName().equals(repositoryName)) {
            throw new DataIntegrityViolationException("No row was inserted due to data violation");
        }
    }

    protected void doStart() throws Exception {
         
        boolean startScheduler = isStartScheduler();
        setStartScheduler(false);
        try {
            super.doStart();
            if (endpoint.isAutoCreate() && hasStartingDirectory()) {
                String dir = endpoint.getConfiguration().getDirectory();
                LOG.debug("Auto creating directory: {}", dir);
                try {
                    operations.buildDirectory(dir, true);
                } catch (GenericFileOperationFailedException e) {
                     
                    LOG.warn(
                            "Error auto creating directory: " + dir + " due " + e.getMessage() + ". This exception is ignored.",
                            e);
                }
            } else if (configuration.isStartingDirectoryMustExist() && hasStartingDirectory()) {
                String dir = endpoint.getConfiguration().getDirectory();
                SmbOperations ops = (SmbOperations) operations;
                boolean exists = ops.existsFolder(dir);
                if (!exists) {
                    throw new GenericFileOperationFailedException("Starting directory does not exist: " + dir);
                }
            }
        } finally {
            if (startScheduler) {
                setStartScheduler(true);
                startScheduler();
            }
        }
    }

    private void doUpsert(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Upsert on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Upsert upsert = table.newUpsert();
        PartialRow row = upsert.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(upsert);
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public void doStop() throws Exception {
        if (ObjectHelper.isEmpty(configuration.getAmazonKinesisClient())) {
            if (kinesisClient != null) {
                kinesisClient.close();
            } else if (Objects.nonNull(kinesisAsyncClient)) {
                kinesisAsyncClient.close();
            }
        }
        if (!configuration.isCborEnabled()) {
            System.clearProperty(CBOR_ENABLED.property());
        }
        super.doStop();
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpManagementServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }
        return answer;
    }

        public void run() {
             
            LOG.info("Listening on port {}", serversocket.getLocalPort());
            while (!Thread.interrupted()) {
                try {

                     
                    final Socket inSocket = serversocket.accept();

                     
                    final Thread t = new RequestHandlerThread(this.service.httpService, inSocket);
                    t.setDaemon(true);
                    t.start();
                } catch (final InterruptedIOException | SocketException ex) {
                     
                    break;
                } catch (final IOException e) {
                    LOG.error("I/O error initialising connection thread: {}", e.getMessage());
                    break;
                }
            }
        }

    protected TransactionErrorHandler createTransactionErrorHandler(
            Route route, Processor processor, ErrorHandlerFactory builder) {
        TransactionErrorHandler answer;
        try {
            ModelCamelContext mcc = (ModelCamelContext) route.getCamelContext();
            answer = (TransactionErrorHandler) mcc.getModelReifierFactory().createErrorHandler(route, builder, processor);
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
        return answer;
    }

    public void process(Exchange exchange, Throwable exception) {
        if (logger.shouldLog()) {
            String output = formatter.format(exchange);
            if (maskingFormatter != null) {
                output = maskingFormatter.format(output);
            }
            output = fireListeners(exchange, output);
            logger.log(output, exception);
            closeListeners(exchange, output);
        }
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpManagementServerConfigurationProperties properties) {
        String authPropertiesFileName = properties.getBasicPropertiesFile();
        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : DEFAULT_REALM;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationConfig.AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                return BasicAuthHandler.create(authenticationProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(
                vertx -> PropertyFileAuthentication.create(vertx, authPropertiesFileName));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    private String getUri(Row r) {
        String u = r.endpoint;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof String) {
            String input = exchange.getIn().getBody(String.class);
            T result = predict(exchange, input);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be String");
        }
    }

    private String createCodeExchangeProperty(final String function) {
         
        String remainder = ifStartsWithReturnRemainder("exchangePropertyAsIndex(", function);
        if (remainder != null) {
            String keyTypeAndIndex = StringHelper.before(remainder, ")");
            if (keyTypeAndIndex == null) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            String[] parts = keyTypeAndIndex.split(",");
            if (parts.length != 3) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            String key = parts[0];
            String type = parts[1];
            String index = parts[2];
            if (ObjectHelper.isEmpty(key) || ObjectHelper.isEmpty(type) || ObjectHelper.isEmpty(index)) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            key = StringHelper.removeQuotes(key);
            key = key.trim();
            type = appendClass(type);
            type = type.replace('$', '.');
            type = type.trim();
            index = StringHelper.removeQuotes(index);
            index = index.trim();
            remainder = StringHelper.after(remainder, ")");
            if (ObjectHelper.isNotEmpty(remainder)) {
                boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
                if (invalid) {
                    throw new SimpleParserException(
                            "Valid syntax: ${exchangePropertyAsIndex(key, type, index).OGNL} was: " + function,
                            token.getIndex());
                }
                return "exchangePropertyAsIndex(exchange, " + type + ", \"" + key + "\", \"" + index + "\")"
                       + ognlCodeMethods(remainder, type);
            } else {
                return "exchangePropertyAsIndex(exchange, " + type + ", \"" + key + "\", \"" + index + "\")";
            }
        }

         
        remainder = ifStartsWithReturnRemainder("exchangePropertyAs(", function);
        if (remainder != null) {
            String keyAndType = StringHelper.before(remainder, ")");
            if (keyAndType == null) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAs(key, type)} was: " + function, token.getIndex());
            }

            String key = StringHelper.before(keyAndType, ",");
            String type = StringHelper.after(keyAndType, ",");
            remainder = StringHelper.after(remainder, ")");
            if (ObjectHelper.isEmpty(key) || ObjectHelper.isEmpty(type)) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAs(key, type)} was: " + function, token.getIndex());
            }
            key = StringHelper.removeQuotes(key);
            key = key.trim();
            type = appendClass(type);
            type = type.replace('$', '.');
            type = type.trim();
            return "exchangePropertyAs(exchange, \"" + key + "\", " + type + ")" + ognlCodeMethods(remainder, type);
        }

         
        remainder = ifStartsWithReturnRemainder("exchangeProperty", function);
        if (remainder != null) {
             
            if (remainder.startsWith(".") || remainder.startsWith("?")) {
                remainder = remainder.substring(1);
            }
             
            if (remainder.startsWith("[") && remainder.endsWith("]")) {
                remainder = remainder.substring(1, remainder.length() - 1);
            }
             
            String key = StringHelper.removeLeadingAndEndingQuotes(remainder);
            key = key.trim();

             
            boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(key);
            if (invalid) {
                throw new SimpleParserException(
                        "Valid syntax: ${exchangeProperty.name[key]} was: " + function, token.getIndex());
            }

             
            String index = null;
            if (key.endsWith("]")) {
                index = StringHelper.between(key, "[", "]");
                if (index != null) {
                    key = StringHelper.before(key, "[");
                }
            }
            if (index != null) {
                index = StringHelper.removeLeadingAndEndingQuotes(index);
                return "exchangePropertyAsIndex(exchange, Object.class, \"" + key + "\", \"" + index + "\")";
            } else if (OgnlHelper.isValidOgnlExpression(remainder)) {
                 
                throw new SimpleParserException(
                        "Valid syntax: ${exchangePropertyAs(key, type)} was: " + function, token.getIndex());
            } else {
                 
                return "exchangeProperty(exchange, \"" + key + "\")";
            }
        }

        return null;
    }

    public StaticServiceCallServiceDiscoveryConfiguration servers(String servers) {
        if (ObjectHelper.isNotEmpty(servers)) {
            String[] parts = servers.split(",");

            if (this.servers == null) {
                this.servers = new ArrayList<>();
            }

            this.servers.addAll(Arrays.asList(parts));
        }

        return this;
    }

    public static DispositionNotificationMultipartReportEntity parseMultipartReportEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName,
            String contentTransferEncoding)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

             
            DispositionNotificationMultipartReportEntity dispositionNotificationMultipartReportEntity
                    = new DispositionNotificationMultipartReportEntity(boundary, contentTransferEncoding, false);  

             
            skipPreambleAndStartBoundary(inbuffer, is, boundary);

             
             
             

             
            Header[] headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType textReportContentType = null;
            String textReportContentTransferEncoding = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    textReportContentType = ContentType.parse(header.getValue());
                } else if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TRANSFER_ENCODING)) {
                    textReportContentTransferEncoding = header.getValue();
                }
            }

             
            if (textReportContentType == null) {
                textReportContentType = ContentType.parse("text/plain").withCharset(StandardCharsets.US_ASCII.name());
            }

            if (!textReportContentType.getMimeType().equalsIgnoreCase(AS2MimeType.TEXT_PLAIN)) {
                throw new HttpException(
                        "Invalid content type '" + textReportContentType.getMimeType()
                                        + "' for first body part of disposition notification");
            }

            String textReportCharsetName = textReportContentType.getCharset() == null
                    ? StandardCharsets.US_ASCII.name() : textReportContentType.getCharset().name();
            TextPlainEntity textReportEntity
                    = parseTextPlainEntityBody(inbuffer, is, boundary, textReportCharsetName,
                            textReportContentTransferEncoding);
            textReportEntity.setHeaders(headers);
            dispositionNotificationMultipartReportEntity.addPart(textReportEntity);

             
             

             
             
             

             
            headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType dispositionNotificationContentType = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    dispositionNotificationContentType = ContentType.parse(header.getValue());
                }
            }
            if (dispositionNotificationContentType == null) {
                throw new HttpException("Failed to find Content-Type header in body part");
            }
            if (!dispositionNotificationContentType.getMimeType()
                    .equalsIgnoreCase(AS2MimeType.MESSAGE_DISPOSITION_NOTIFICATION)) {
                throw new HttpException(
                        "Invalid content type '" + dispositionNotificationContentType.getMimeType()
                                        + "' for second body part of disposition notification");
            }

            String dispositionNotificationCharsetName = dispositionNotificationContentType.getCharset() == null
                    ? StandardCharsets.US_ASCII.name() : dispositionNotificationContentType.getCharset().name();
            AS2MessageDispositionNotificationEntity messageDispositionNotificationEntity
                    = parseMessageDispositionNotificationEntityBody(
                            inbuffer, is, boundary, dispositionNotificationCharsetName);
            messageDispositionNotificationEntity.setHeaders(headers);
            dispositionNotificationMultipartReportEntity.addPart(messageDispositionNotificationEntity);

             
             

            return dispositionNotificationMultipartReportEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse text entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }

    }

    protected void configureFormat(F format) {
        if (lineSeparator != null) {
            format.setLineSeparator(lineSeparator);
        }
        if (normalizedLineSeparator != null) {
            format.setNormalizedNewline(normalizedLineSeparator);
        }
        if (comment != null) {
            format.setComment(comment);
        }
    }

    protected static JsonObject getJsonObject(Path outputFile, long timeout) {
        StopWatch watch = new StopWatch();
        while (watch.taken() < 5000) {
            File f = outputFile.toFile();
            try {
                 
                Thread.sleep(100);

                if (Files.exists(outputFile) && f.length() > 0) {
                    String text = Files.readString(outputFile);
                    return (JsonObject) Jsoner.deserialize(text);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

    protected SubmitSm[] createSubmitSm(Exchange exchange) throws SmppException {
        Message message = exchange.getIn();
        SubmitSm template = createSubmitSmTemplate(exchange);
        byte[][] segments = splitBody(message);

         
        ESMClass esmClass = message.getHeader(SmppConstants.ESM_CLASS, ESMClass.class);
        if (esmClass != null) {
            template.setEsmClass(esmClass.value());
        } else if (segments.length > 1) {
             
            template.setEsmClass(new ESMClass(MessageMode.DEFAULT, MessageType.DEFAULT, GSMSpecificFeature.UDHI).value());
        }

        SubmitSm[] submitSms = new SubmitSm[segments.length];
        for (int i = 0; i < segments.length; i++) {
            SubmitSm submitSm = SmppUtils.copySubmitSm(template);
            submitSm.setShortMessage(segments[i]);
            submitSms[i] = submitSm;
        }
        setRegisterDeliveryReceiptFlag(submitSms, message);
        return submitSms;
    }

    public Integer getInteger(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).intValue();
    }

    private String determineKey(Exchange exchange) {
        String key = exchange.getIn().getHeader(IBMCOSConstants.KEY, String.class);
        if (key == null) {
            key = getConfiguration().getKeyName();
        }
        if (key == null) {
            throw new IllegalArgumentException("Key must be specified");
        }
        return key;
    }

    public static Expression exchangeOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                 
                 
                Expression ognlExp = bean.createExpression(null, new Object[] { null, exchange, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "exchangeOgnl(" + ognl + ")";
            }
        };
    }

    private <T> T getRequiredHeader(
            Exchange exchange,
            String headerName,
            Class<T> headerType,
            Supplier<T> configurationValue,
            String errorMessage) {
        T value = exchange.getIn().getHeader(headerName, headerType);
        if (ObjectHelper.isEmpty(value)) {
            value = configurationValue.get();
        }
        if (ObjectHelper.isEmpty(value)) {
            throw new IllegalArgumentException(errorMessage);
        }
        return value;
    }

    public int read(char[] cbuf, int off, int len) throws IOException {
        int tlen = 0;
        while (len > 0) {
            int n = ensureBuffering(len);
            if (n < 0) {
                break;
            }
            int clen = Math.min(len, n);
            System.arraycopy(buffer, 0, cbuf, off, clen);
            System.arraycopy(buffer, clen, buffer, 0, buffer.length - clen);
            bpos -= clen;
            len -= clen;
            off += clen;
            tlen += clen;
        }
        return tlen > 0 ? tlen : -1;
    }

    private void doCreate(Exchange exchange) {
        final Message msg = exchange.getIn();
        final Payload payload = createPayload(msg);
        final String containerName = msg.getHeader(SwiftConstants.CONTAINER_NAME, String.class);
        final String objectName = msg.getHeader(SwiftConstants.OBJECT_NAME, String.class);
        StringHelper.notEmpty(containerName, "Container name");
        StringHelper.notEmpty(objectName, "Object name");
        final String etag = os.objectStorage().objects().put(containerName, objectName, payload);
        msg.setBody(etag);
    }

    public Short getShort(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    private RedeliveryPolicy resolveRedeliveryPolicy(DeadLetterChannelDefinition definition, CamelContext camelContext) {
        if (definition.hasRedeliveryPolicy() && definition.getRedeliveryPolicyRef() != null) {
            throw new IllegalArgumentException(
                    "Cannot have both redeliveryPolicy and redeliveryPolicyRef set at the same time.");
        }

        RedeliveryPolicy answer = null;
        RedeliveryPolicyDefinition def = definition.hasRedeliveryPolicy() ? definition.getRedeliveryPolicy() : null;
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
             
            def = lookupByNameAndType(definition.getRedeliveryPolicyRef(), RedeliveryPolicyDefinition.class);
        }
        if (def != null) {
            answer = ErrorHandlerReifier.createRedeliveryPolicy(def, camelContext, null);
        }
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
            answer = mandatoryLookup(definition.getRedeliveryPolicyRef(), RedeliveryPolicy.class);
        }
        if (answer == null) {
            answer = RedeliveryPolicy.DEFAULT_POLICY;
        }
        return answer;
    }

    protected HazelcastInstance getOrCreateHzClientInstance(CamelContext context, Map<String, Object> parameters)
            throws Exception {
        HazelcastInstance hzInstance = null;
        ClientConfig config = null;

         
        hzInstance = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_INSTANCE_PARAM, HazelcastInstance.class);

         
        if (hzInstance == null && parameters.get(HAZELCAST_INSTANCE_NAME_PARAM) != null) {
            hzInstance = HazelcastClient.getHazelcastClientByName((String) parameters.get(HAZELCAST_INSTANCE_NAME_PARAM));
        }

         
         
        if (hzInstance == null) {
            config = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_CONFIGU_PARAM, ClientConfig.class);
            if (config == null) {
                String configUri = getAndRemoveParameter(parameters, HAZELCAST_CONFIGU_URI_PARAM, String.class);
                if (configUri != null) {
                    configUri = getCamelContext().resolvePropertyPlaceholders(configUri);
                }
                if (configUri != null) {
                    InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configUri);
                    config = new XmlClientConfigBuilder(is).build();
                }
            }

            if (hazelcastInstance == null && config == null) {
                config = new XmlClientConfigBuilder().build();
                 
                config.getProperties().setProperty("hazelcast.version.check.enabled", "false");
                config.getProperties().setProperty("hazelcast.phone.home.enabled", "false");

                hzInstance = HazelcastClient.newHazelcastClient(config);
            } else if (config != null) {
                hzInstance = HazelcastClient.newHazelcastClient(config);
            }

            if (hzInstance != null) {
                if (this.customHazelcastInstances.add(hzInstance)) {
                    LOGGER.debug("Add managed HZ instance {}", hzInstance.getName());
                }
            }
        }

        return hzInstance == null ? hazelcastInstance : hzInstance;
    }

    public static String nodeValue(final String namespace, final String node) {
        Objects.requireNonNull(namespace);
        Objects.requireNonNull(node);

        final StringBuilder builder = new StringBuilder("RAW(");
        appendNamespace(builder, namespace);
        builder.append(';');
        appendNodeId(builder, node);
        builder.append(')');
        return builder.toString();
    }

    public void getBatch(
            String jobId, String batchId, Map<String, List<String>> headers, final BatchInfoResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchUrl(jobId, batchId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfo value = null;
                try {
                    value = unmarshalResponse(response, get, BatchInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(RouteDumpDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("AWS Secrets Manager:");
            sb.append(String.format("\n    Region: %s", propertiesFunction.getRegion()));
            if (propertiesFunction.isDefaultCredentialsProvider()) {
                sb.append("\n    Login: DefaultCredentialsProvider");
            } else if (propertiesFunction.isProfleCredentialsProvider()) {
                sb.append("\n    Login: ProfileCredentialsProvider");
            } else {
                sb.append("\n    Login: Access and Secret Keys");
            }
            AwsVaultConfiguration aws = getCamelContext().getVaultConfiguration().getAwsVaultConfiguration();
            if (aws != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", aws.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", aws.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    private void configureFifoAttributes(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        if (getEndpoint().getConfiguration().isFifoQueue()) {
             
            MessageGroupIdStrategy messageGroupIdStrategy = getEndpoint().getConfiguration().getMessageGroupIdStrategy();
            String messageGroupId = messageGroupIdStrategy.getMessageGroupId(exchange);
            request.messageGroupId(messageGroupId);

            MessageDeduplicationIdStrategy messageDeduplicationIdStrategy
                    = getEndpoint().getConfiguration().getMessageDeduplicationIdStrategy();
            String messageDeduplicationId = messageDeduplicationIdStrategy.getMessageDeduplicationId(exchange);
            request.messageDeduplicationId(messageDeduplicationId);

        }
    }

    public void onPutAsync(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final CompletableFuture<Object> result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putAsync(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putAsync(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.putAsync(key, value);
        }

        setResult(message, result);
    }

    public String retrieveOidcToken() {
        if (oidcToken == null || !cacheTokens) {
            try {
                oidcToken = IOHelper
                        .loadText(ResourceHelper.resolveMandatoryResourceAsInputStream(getCamelContext(), oidcTokenPath))
                        .trim();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        return oidcToken;
    }

    public FhirConfiguration getEndpointConfiguration(FhirApiName apiName) {
        FhirConfiguration result = null;
        switch (apiName) {
            case CAPABILITIES:
                result = new FhirCapabilitiesEndpointConfiguration();
                break;
            case CREATE:
                result = new FhirCreateEndpointConfiguration();
                break;
            case DELETE:
                result = new FhirDeleteEndpointConfiguration();
                break;
            case HISTORY:
                result = new FhirHistoryEndpointConfiguration();
                break;
            case LOAD_PAGE:
                result = new FhirLoadPageEndpointConfiguration();
                break;
            case META:
                result = new FhirMetaEndpointConfiguration();
                break;
            case OPERATION:
                result = new FhirOperationEndpointConfiguration();
                break;
            case PATCH:
                result = new FhirPatchEndpointConfiguration();
                break;
            case READ:
                result = new FhirReadEndpointConfiguration();
                break;
            case SEARCH:
                result = new FhirSearchEndpointConfiguration();
                break;
            case TRANSACTION:
                result = new FhirTransactionEndpointConfiguration();
                break;
            case UPDATE:
                result = new FhirUpdateEndpointConfiguration();
                break;
            case VALIDATE:
                result = new FhirValidateEndpointConfiguration();
                break;
        }
        return result;
    }

    protected void doStart() throws Exception {
        super.doStart();

         
        PropertiesComponent pc = camelContext.getPropertiesComponent();
        PropertiesFunction pf = pc.getPropertiesFunction("configmap");
        if (pf instanceof ConfigMapPropertiesFunction) {
            propertiesFunction = (ConfigMapPropertiesFunction) pf;
            LOG.info("Auto-detecting configmaps from properties-function: {}", pf.getName());
        }
         
        configmaps = camelContext.getVaultConfiguration().kubernetesConfigmaps().getConfigmaps();
        if (ObjectHelper.isEmpty(configmaps) && propertiesFunction == null) {
            throw new IllegalArgumentException("Configmaps must be configured on Kubernetes configmaps vault configuration");
        }

        kubernetesClient = propertiesFunction.getClient();
    }

    private void validateUri(String uri) throws IllegalArgumentException {
        String[] s = uri.split(":");
        if (s.length < 2) {
            throw new IllegalArgumentException(INVALID_URI);
        }
        String[] t = s[1].split("\\?");

        if (t.length < 1) {
            throw new IllegalArgumentException(INVALID_URI);
        }

        this.uri = t[0].trim();
        if (this.uri.startsWith("//")) {
            this.uri = this.uri.substring(2);
        }

        if (!TYPES_LIST.contains(this.uri)) {
            throw new IllegalArgumentException(INVALID_URI);
        }
    }

    protected void doStop() throws Exception {
        if (listenerContainer != null) {

            if (getEndpoint().isAsyncStopListener()) {
                getEndpoint().getAsyncStartStopExecutorService().submit(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            stopAndDestroyListenerContainer();
                        } catch (Exception e) {
                            LOG.warn("Error stopping listener container on destination: {}. This exception will be ignored.",
                                    getDestinationName(), e);
                        }
                    }

                    @Override
                    public String toString() {
                        return "AsyncStopListenerTask[" + getDestinationName() + "]";
                    }
                });
            } else {
                stopAndDestroyListenerContainer();
            }
        }

        super.doStop();
    }

    public static <I, T extends Throwable> Consumer<I> wrapAsConsumer(ThrowingConsumer<I, T> consumer) {
        return new Consumer<>() {
            @Override
            public void accept(I in) {
                try {
                    consumer.accept(in);
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    public String getLabel() {
        if (endpointUriToString == null) {
            String value = null;
            try {
                value = getEndpointUri();
            } catch (RuntimeException e) {
                 
            }
             
            endpointUriToString = URISupport.sanitizeUri(value);
        }

        String uri = endpointUriToString;
        return "to[" + uri + "]";
    }

    private void updateVideoSource(Exchange exchange, ClientConfigurations clientConfigurations) {
        String videoBase64 = exchange.getProperty(FaceRecognitionProperties.FACE_VIDEO_BASE64, String.class);
        clientConfigurations.setVideoBase64(StringUtils.isEmpty(videoBase64) ? this.endpoint.getVideoBase64() : videoBase64);
        if (!StringUtils.isEmpty(clientConfigurations.getVideoBase64())) {
            clientConfigurations.setInputSourceType(InputSourceType.BASE64);
            return;
        }
        String videoUrl = exchange.getProperty(FaceRecognitionProperties.FACE_VIDEO_URL, String.class);
        clientConfigurations.setVideoUrl(StringUtils.isEmpty(videoUrl) ? this.endpoint.getVideoUrl() : videoUrl);
        if (!StringUtils.isEmpty(clientConfigurations.getVideoUrl())) {
            clientConfigurations.setInputSourceType(InputSourceType.URL);
            return;
        }
        String videoFilePath = exchange.getProperty(FaceRecognitionProperties.FACE_VIDEO_FILE_PATH, String.class);
        clientConfigurations
                .setVideoFilePath(StringUtils.isEmpty(videoFilePath) ? this.endpoint.getVideoFilePath() : videoFilePath);
        if (!StringUtils.isEmpty(clientConfigurations.getVideoFilePath())) {
            clientConfigurations.setInputSourceType(InputSourceType.FILE_PATH);
            return;
        }
        throw new IllegalArgumentException("any one of video base64, url and filePath needs to be set");
    }

    public void setDataObjectFormatIdentifierDocumentationReferences(
            List<String> dataObjectFormatIdentifierDocumentationReferences) {
        if (dataObjectFormatIdentifierDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'dataObjectFormatIdentifierDocumentationReferences' is null");
        }
        for (String ref : dataObjectFormatIdentifierDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one reference of the identifier of the data object format is null or empty");
            }
        }
        this.dataObjectFormatIdentifierDocumentationReferences
                = new ArrayList<>(dataObjectFormatIdentifierDocumentationReferences);
    }

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Failover).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    public PathHandler removeExactPath(final String path) {
        lock.lock();
        try {
            super.removeExactPath(path);
            handlers.remove(path);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    private Integer downloadFromGist() throws Exception {
        StringJoiner all = new StringJoiner(",");

        fetchGistUrls(file, all);

        if (all.length() > 0) {
             
            if (!directory.equals(".")) {
                Path dirPath = Paths.get(directory);
                if (cleanDirectory) {
                     
                    CommandHelper.cleanExportDir(directory);
                }
                Files.createDirectories(dirPath);
            }

            CamelContext tiny = new DefaultCamelContext();
            try (GistResourceResolver resolver = new GistResourceResolver()) {
                resolver.setCamelContext(tiny);
                for (String u : all.toString().split(",")) {
                    Resource resource = resolver.resolve(u);
                    if (!resource.exists()) {
                        throw new ResourceDoesNotExist(resource);
                    }
                    String loc = resource.getLocation();
                    String name = FileUtil.stripPath(loc);
                    Path targetPath = Paths.get(directory, name);
                    try (OutputStream os = Files.newOutputStream(targetPath)) {
                        IOUtils.copy(resource.getInputStream(), os);
                    }
                }
            }
        }

        return 0;
    }

    private RemoveImageCmd executeRemoveImageRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Remove Image Request");

        String imageId = DockerHelper.getProperty(DockerConstants.DOCKER_IMAGE_ID, configuration, message, String.class);

        ObjectHelper.notNull(imageId, "Image ID must be specified");

        RemoveImageCmd removeImagesCmd = client.removeImageCmd(imageId);

        Boolean force = DockerHelper.getProperty(DockerConstants.DOCKER_FORCE, configuration, message, Boolean.class);

        if (force != null) {
            removeImagesCmd.withForce(force);
        }

        Boolean noPrune = DockerHelper.getProperty(DockerConstants.DOCKER_NO_PRUNE, configuration, message, Boolean.class);

        if (noPrune != null) {
            removeImagesCmd.withNoPrune(noPrune);
        }

        return removeImagesCmd;

    }

    public JobResponse completeJob(JobRequest message) {
        JobResponse resultMessage = new JobResponse();

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.CompleteJobRequest.Builder builder = GatewayOuterClass.CompleteJobRequest.newBuilder()
                    .setJobKey(message.getJobKey());
            if (!message.getVariables().isEmpty()) {
                builder = builder.setVariables(objectMapper.writeValueAsString(message.getVariables()));
            }
            GatewayOuterClass.CompleteJobRequest request = builder.build();
            GatewayOuterClass.CompleteJobResponse completeJobResponse = stub.completeJob(request);

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot complete Job %s", message.getJobKey()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        } catch (JsonProcessingException exception) {
            LOG.error("Could not convert variables to JSON", exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    public XMLSecurityDataFormat() {
        this.xmlCipherAlgorithm = XMLCipher.AES_256_GCM;
        this.secureTag = "";
        this.secureTagContents = true;

         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

    private String getSecretKey(ImageRecognitionEndpoint endpoint) {
        if (!StringUtils.isEmpty(endpoint.getSecretKey())) {
            return endpoint.getSecretKey();
        } else if (endpoint.getServiceKeys() != null
                && !StringUtils.isEmpty(endpoint.getServiceKeys().getSecretKey())) {
            return endpoint.getServiceKeys().getSecretKey();
        } else {
            throw new IllegalArgumentException("authentication parameter 'secret key (SK)' not found");
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        if (remaining == null || remaining.isBlank()) {
            throw new IllegalArgumentException("A queue or topic name must be specified.");
        }

        final ServiceBusConfiguration configuration
                = this.configuration != null ? this.configuration.copy() : new ServiceBusConfiguration();

         
        configuration.setTopicOrQueueName(remaining);

        final ServiceBusEndpoint endpoint = new ServiceBusEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);

         
        if (endpoint.getConfiguration().getTokenCredential() == null) {
            if (endpoint.getConfiguration().getCredentialType() == null) {
                endpoint.getConfiguration().setCredentialType(CredentialType.CONNECTION_STRING);
            }
        } else {
            boolean azure = endpoint.getConfiguration().getTokenCredential() instanceof DefaultAzureCredential;
            endpoint.getConfiguration()
                    .setCredentialType(azure ? CredentialType.AZURE_IDENTITY : CredentialType.TOKEN_CREDENTIAL);
        }

        return endpoint;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        AtomicBoolean remoteVisible = new AtomicBoolean();
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        JsonArray array = (JsonArray) root.get("routes");
                        for (int i = 0; i < array.size(); i++) {
                            JsonObject o = (JsonObject) array.get(i);
                            Row row = new Row();
                            row.name = context.getString("name");
                            if ("CamelJBang".equals(row.name)) {
                                row.name = ProcessHelper.extractName(root, ph);
                            }
                            row.pid = Long.toString(ph.pid());
                            row.routeId = o.getString("routeId");
                            row.group = o.getString("group");
                            row.description = o.getString("description");
                            row.note = o.getString("note");
                            row.from = o.getString("from");
                            Boolean bool = o.getBoolean("remote");
                            if (bool != null) {
                                 
                                remoteVisible.set(true);
                                row.remote = bool;
                            }
                            row.source = o.getString("source");
                            row.state = o.getString("state");
                            row.age = o.getString("uptime");
                            row.uptime = row.age != null ? TimeUtils.toMilliSeconds(row.age) : 0;
                            JsonObject eo = (JsonObject) o.get("lastError");
                            if (eo != null) {
                                row.lastErrorPhase = eo.getString("phase");
                                row.lastErrorTimestamp = eo.getLongOrDefault("timestamp", 0);
                                row.lastErrorMessage = eo.getString("message");
                                row.stackTrace = eo.getCollection("stackTrace");
                            }
                            Map<String, ?> stats = o.getMap("statistics");
                            if (stats != null) {
                                Object load = stats.get("load01");
                                if (load != null) {
                                    row.load01 = load.toString();
                                }
                                load = stats.get("load05");
                                if (load != null) {
                                    row.load05 = load.toString();
                                }
                                load = stats.get("load15");
                                if (load != null) {
                                    row.load15 = load.toString();
                                }
                                Object thp = stats.get("exchangesThroughput");
                                if (thp != null) {
                                    row.throughput = thp.toString();
                                }
                                Object coverage = stats.get("coverage");
                                if (coverage != null) {
                                    row.coverage = coverage.toString();
                                }
                                row.total = stats.get("exchangesTotal").toString();
                                row.inflight = stats.get("exchangesInflight").toString();
                                row.failed = stats.get("exchangesFailed").toString();
                                row.mean = stats.get("meanProcessingTime").toString();
                                if ("-1".equals(row.mean)) {
                                    row.mean = null;
                                }
                                row.max = stats.get("maxProcessingTime").toString();
                                row.min = stats.get("minProcessingTime").toString();
                                Object last = stats.get("lastProcessingTime");
                                if (last != null) {
                                    row.last = last.toString();
                                }
                                last = stats.get("deltaProcessingTime");
                                if (last != null) {
                                    row.delta = last.toString();
                                }
                                last = stats.get("lastCreatedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastStarted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastCompletedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastCompleted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastFailedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastFailed = TimeUtils.printSince(time);
                                }
                            }

                            boolean add = true;
                            if (mean > 0 && (row.mean == null || Long.parseLong(row.mean) < mean)) {
                                add = false;
                            }
                            if (limit > 0 && rows.size() >= limit) {
                                add = false;
                            }
                            if (add && filter != null) {
                                boolean match = false;
                                for (String f : filter) {
                                    if (!match) {
                                        String from = StringHelper.before(row.from, "?", row.from);
                                        String w = f.endsWith("*") ? f : f + "*";  
                                        match = PatternHelper.matchPattern(row.routeId, f)
                                                || PatternHelper.matchPattern(from, w);
                                    }
                                }
                                if (!match) {
                                    add = false;
                                }
                            }
                            if (add && group != null) {
                                add = PatternHelper.matchPatterns(row.group, group);
                            }
                            if (add && running) {
                                add = "Started".equals(row.state);
                            }
                            if (add) {
                                rows.add(row);
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            if (error) {
                for (Row r : rows) {
                    boolean error = r.lastErrorPhase != null;
                    if (error) {
                        printErrorTable(r, remoteVisible.get());
                    }
                }
            } else {
                printTable(rows, remoteVisible.get());
            }
        }

        return 0;
    }

    public static JsonObject asJsonObject(TransformerModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("from", model.getFrom());
        obj.put("to", model.getTo());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("transformer", obj);
        return wrapper;
    }

  final public OutParameter OutParameter() throws ParseException {Token sqlTypeToken;
     String outValueMapKey;
     Integer scale = null;
     String typeName = null;
    jj_consume_token(2);
    sqlTypeToken = ParameterSqlType();
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case SCALE:{
      scale = Scale();
      break;
      }
    default:
      jj_la1[6] = jj_gen;
      ;
    }
    jj_consume_token(1);
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case PARAMETER_NAME:{
      typeName = ParameterName();
      jj_consume_token(1);
      break;
      }
    default:
      jj_la1[7] = jj_gen;
      ;
    }
    outValueMapKey = OutHeader();
{if ("" != null) return new OutParameter(ParseHelper.parseSqlType(sqlTypeToken, classResolver), outValueMapKey, scale, typeName);}
    throw new Error("Missing return statement in function");
}

    protected void doCall(Map<String, Object> options, Function<ManagedRouteGroupMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRouteGroup(route.getGroup()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .distinct()
                    .sorted(RouteGroupDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    public static JsonObject asJsonObject(DevConsoleModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("group", model.getGroup());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("console", obj);
        return wrapper;
    }

    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("KeyManagersParameters[keyStore=");
        builder.append(keyStore);
        builder.append(", keyPassword=");
        builder.append("********");
        builder.append(", provider=");
        builder.append(provider);
        builder.append(", algorithm=");
        builder.append(algorithm);
        builder.append("]");
        return builder.toString();
    }

    public void setMessageGroupIdStrategy(String strategy) {
        if ("useConstant".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new ConstantMessageGroupIdStrategy();
        } else if ("useExchangeId".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new ExchangeIdMessageGroupIdStrategy();
        } else if ("usePropertyValue".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new PropertyValueMessageGroupIdStrategy();
        } else {
            throw new IllegalArgumentException("Unrecognised MessageGroupIdStrategy: " + strategy);
        }
    }

    public Sheets makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Google Sheets client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Sheets.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Google Sheets client.", e);
        }
    }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode outputs = node.get("outputs");
        if (outputs != null && outputs.isArray() && outputs.size() > 0) {
            JsonNode firstOutput = outputs.get(0);
            JsonNode stopReason = firstOutput.get("stop_reason");
            return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
        }
        return null;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int processedExchanges = 0;
        while (!exchanges.isEmpty()) {
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());

             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
            processedExchanges++;
        }
        return processedExchanges;
    }

    private void doUpdate(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            Iterator<?> iter;
            if (in instanceof Map) {
                 
                iter = Collections.singletonList(in).iterator();
            } else {
                iter = ObjectHelper.createIterator(in);
            }
            while (iter.hasNext()) {
                Object value = iter.next();
                LOG.trace("Updating: {} using statement: {}", value, statement);
                result = session.update(statement, value);
                doProcessResult(exchange, result, session);
            }
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        if (definition.getLibrary() == AvroLibrary.ApacheAvro) {
            if (definition.getInstanceClassName() == null) {
                if (definition.getUnmarshalType() != null) {
                    properties.put("instanceClassName", definition.getUnmarshalType().getName());
                } else if (definition.getUnmarshalTypeName() != null) {
                    properties.put("instanceClassName", definition.getUnmarshalTypeName());
                }
            } else {
                properties.put("instanceClassName", definition.getInstanceClassName());
            }
            properties.put("schema", definition.getSchema());
        } else if (definition.getLibrary() == AvroLibrary.Jackson) {
            properties.put("objectMapper", asRef(definition.getObjectMapper()));
            if (definition.getUseDefaultObjectMapper() == null) {
                 
                properties.put("useDefaultObjectMapper", "true");
            } else {
                properties.put("useDefaultObjectMapper", definition.getUseDefaultObjectMapper());
            }
            properties.put("autoDiscoverObjectMapper", definition.getAutoDiscoverObjectMapper());
            properties.put("unmarshalType", or(
                    or(definition.getUnmarshalType(), definition.getUnmarshalTypeName()), definition.getInstanceClassName()));
            properties.put("jsonView", or(definition.getJsonView(), definition.getJsonViewTypeName()));
            properties.put("include", definition.getInclude());
            properties.put("allowJmsType", definition.getAllowJmsType());
            properties.put("collectionType", or(definition.getCollectionType(), definition.getCollectionTypeName()));
            properties.put("useList", definition.getUseList());
            properties.put("moduleClassNames", definition.getModuleClassNames());
            properties.put("moduleRefs", definition.getModuleRefs());
            properties.put("enableFeatures", definition.getEnableFeatures());
            properties.put("disableFeatures", definition.getDisableFeatures());
            properties.put("allowUnmarshallType", definition.getAllowUnmarshallType());
            properties.put("schemaResolver", asRef(definition.getSchemaResolver()));
            properties.put("autoDiscoverSchemaResolver", definition.getAutoDiscoverSchemaResolver());
        }
    }

    public XMLSecurityDataFormat() {
        this.xmlCipherAlgorithm = XMLCipher.AES_256_GCM;
        this.secureTag = "";
        this.secureTagContents = true;

         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

        public void presence(PubNub pubnub, PNPresenceEventResult presence) {
            Exchange exchange = createExchange(true);
            Message inmessage = exchange.getIn();
            inmessage.setBody(presence);
            inmessage.setHeader(TIMETOKEN, presence.getTimetoken());
            inmessage.setHeader(CHANNEL, presence.getChannel());
            inmessage.setHeader(Exchange.MESSAGE_TIMESTAMP, presence.getTimetoken());
            try {
                getProcessor().process(exchange);
            } catch (Exception e) {
                getExceptionHandler().handleException("Error processing exchange", e);
            }
        }

    public void index(Object result) {
        if (result instanceof ODataFeed) {
            index((ODataFeed) result);
        } else if (result instanceof Iterable) {
            index((Iterable<?>) result);
        } else if (result instanceof ODataEntry) {
            index((ODataEntry) result);
        } else {
            indexDefault(result);
        }
    }

    public static BoxAPIConnection createAppEnterpriseAuthenticatedConnection(BoxConfiguration configuration) {
         
        JWTEncryptionPreferences encryptionPref = new JWTEncryptionPreferences();
        encryptionPref.setPublicKeyID(configuration.getPublicKeyId());

        try {
            encryptionPref.setPrivateKey(new String(Files.readAllBytes(Paths.get(configuration.getPrivateKeyFile()))));
        } catch (Exception e) {
            throw new RuntimeCamelException("Box API connection failed: could not read privateKeyFile", e);
        }

        encryptionPref.setPrivateKeyPassword(configuration.getPrivateKeyPassword());
        encryptionPref.setEncryptionAlgorithm(configuration.getEncryptionAlgorithm());

        IAccessTokenCache accessTokenCache = configuration.getAccessTokenCache();
        if (accessTokenCache == null) {
            accessTokenCache = new InMemoryLRUAccessTokenCache(configuration.getMaxCacheEntries());
        }

        try {
            return BoxDeveloperEditionAPIConnection.getAppEnterpriseConnection(configuration.getEnterpriseId(),
                    configuration.getClientId(), configuration.getClientSecret(), encryptionPref, accessTokenCache);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    String.format("Box API connection failed: API returned the error code %d%n%n%s",
                            e.getResponseCode(), e.getResponse()),
                    e);
        }

    }

    private static void setAdditionalConfiguration(
            CamelContext camelContext, RestConfiguration config, DataFormat dataFormat, String prefix) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            PropertyBindingSupport.build().bind(camelContext, dataFormat, copy);
        }
    }

    protected String populateContentOnMimeMessage(MimeMessage part, MailConfiguration configuration, Exchange exchange)
            throws MessagingException, IOException {

        String contentType = determineContentType(configuration, exchange);

        LOG.trace("Using Content-Type {} for MimeMessage: {}", contentType, part);

        String body = exchange.getIn().getBody(String.class);
        if (body == null) {
            body = "";
        }

         
        DataSource ds = new ByteArrayDataSource(body, contentType);
        part.setDataHandler(new DataHandler(ds));

         
        part.setHeader("Content-Type", contentType);

        return contentType;
    }

    protected void doStop() throws Exception {
        super.doStop();

        if (executor != null) {
            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public void process(String uri, Function<? super Publisher<Exchange>, ?> processor) {
        try {
            context.addRoutes(new RouteBuilder() {
                @Override
                public void configure() throws Exception {
                    from(uri)
                            .process(exchange -> {
                                Exchange copy = exchange.copy();
                                Object result = processor.apply(Flowable.just(copy));
                                exchange.getIn().setBody(result);
                            })
                            .process(unwrapStreamProcessorSupplier.get());
                }
            });
        } catch (Exception e) {
            throw new IllegalStateException("Unable to add reactive stream processor to the direct URI: " + uri, e);
        }
    }

    private WatsonLanguageOperations determineOperation(Exchange exchange) {
        WatsonLanguageOperations operation
                = exchange.getIn().getHeader(WatsonLanguageConstants.OPERATION, WatsonLanguageOperations.class);

        if (operation == null) {
            operation = getEndpoint().getConfiguration().getOperation();
        }

        if (operation == null) {
            throw new IllegalArgumentException("Operation must be specified");
        }

        return operation;
    }

    public void writeTo(OutputStream outstream) throws IOException {
        NoCloseOutputStream ncos = new NoCloseOutputStream(outstream);

         
        if (!isMainBody()) {
            try (CanonicalOutputStream canonicalOutstream = new CanonicalOutputStream(ncos, StandardCharsets.US_ASCII.name())) {

                for (Header header : getAllHeaders()) {
                    canonicalOutstream.writeln(header.toString());
                }
                canonicalOutstream.writeln();  
                                              
                                              
            }
        }

         
        String transferEncoding = getContentTransferEncoding() == null ? null : getContentTransferEncoding().getValue();
        try (OutputStream transferEncodedStream = EntityUtils.encode(ncos, transferEncoding)) {

            transferEncodedStream.write(signature);
        } catch (Exception e) {
            throw new IOException("Failed to write to output stream", e);
        }
    }

    public static String extractState(int status) {
        if (status <= 4) {
            return "Starting";
        } else if (status == 5) {
            return "Running";
        } else if (status == 6) {
            return "Suspending";
        } else if (status == 7) {
            return "Suspended";
        } else if (status == 8) {
            return "Terminating";
        } else if (status == 9) {
            return "Terminated";
        } else {
            return "Terminated";
        }
    }

    public static String extractSourceLocationId(String location) {
        int cnt = StringHelper.countChar(location, ':');
        if (cnt >= 1) {
            int pos = location.lastIndexOf(':');
            return location.substring(pos + 1);
        } else {
            return null;
        }
    }

    protected void doGet(Exchange exchange, String namespaceName) {
        String customResourceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CRD_INSTANCE_NAME, String.class);
        if (ObjectHelper.isEmpty(customResourceName)) {
            throw new IllegalArgumentException("Get a specific custom resource require specify a custom resource name");
        }
        JsonObject customResourceJSON = new JsonObject();
        try {
            customResourceJSON = new JsonObject(
                    getEndpoint().getKubernetesClient().genericKubernetesResources(getCRDContext(exchange.getIn()))
                            .inNamespace(namespaceName)
                            .withName(customResourceName)
                            .require()
                            .get());

        } catch (KubernetesClientException e) {
            if (e.getCode() == 404) {
                LOG.info("Custom resource instance not found", e);
            } else {
                throw e;
            }
        }

        prepareOutboundMessage(exchange, customResourceJSON);
    }

    public static void parseXmlRouteCSimpleExpressions(
            InputStream xml, String baseDir, String fullyQualifiedFileName,
            List<CamelCSimpleExpressionDetails> csimpleExpressions) {

         
         
        Document dom = getDocument(xml);
        if (dom != null) {
            List<Node> nodes = CamelXmlHelper.findAllLanguageExpressions(dom, "csimple");
            for (Node node : nodes) {
                String simple = node.getTextContent();
                String lineNumber = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER);
                String lineNumberEnd = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER_END);

                 
                String fileName = getFileName(baseDir, fullyQualifiedFileName);

                CamelCSimpleExpressionDetails detail = new CamelCSimpleExpressionDetails();
                detail.setFileName(fileName);
                detail.setLineNumber(lineNumber);
                detail.setLineNumberEnd(lineNumberEnd);
                detail.setCsimple(simple);

                String column = (String) node.getUserData(XmlLineNumberParser.COLUMN_NUMBER);
                if (column != null) {
                    detail.setLinePosition(Integer.parseInt(column));
                }

                 
                boolean asPredicate = isSimplePredicate(node);
                detail.setPredicate(asPredicate);
                detail.setExpression(!asPredicate);

                csimpleExpressions.add(detail);
            }
        }
    }

    public static List<RestConfigurationDetails> parseRestConfiguration(
            JavaClassSource clazz, String fullyQualifiedFileName,
            boolean includeInlinedRouteBuilders) {

        List<MethodSource<JavaClassSource>> methods = findAllConfigureMethods(clazz, includeInlinedRouteBuilders);

        CamelJavaRestDslParserHelper parser = new CamelJavaRestDslParserHelper();
        List<RestConfigurationDetails> list = new ArrayList<>();
        for (MethodSource<JavaClassSource> configureMethod : methods) {
             
            List<RestConfigurationDetails> details
                    = parser.parseRestConfiguration(clazz, fullyQualifiedFileName, configureMethod);
            list.addAll(details);
        }
         
        Collections.reverse(list);

        return list;
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    public Properties createConsumerProperties() {
        Properties props = new Properties();
        addPropertyIfNotEmpty(props, ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, getKeyDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, getValueDeserializer());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MIN_BYTES_CONFIG, getFetchMinBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_BYTES_CONFIG, getFetchMaxBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, getHeartbeatIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, getMaxPartitionFetchBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, getSessionTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, getMaxPollIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.MAX_POLL_RECORDS_CONFIG, getMaxPollRecords());
        addPropertyIfNotEmpty(props, ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, getInterceptorClasses());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, getAutoOffsetReset());
        addPropertyIfNotEmpty(props, ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG, getConnectionMaxIdleMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, getAutoCommitEnable());
        addPropertyIfNotEmpty(props, ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, getPartitionAssignor());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECEIVE_BUFFER_CONFIG, getReceiveBufferBytes());
        addPropertyIfNotEmpty(props, ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, getConsumerRequestTimeoutMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, getAutoCommitIntervalMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CHECK_CRCS_CONFIG, getCheckCrcs());
        addPropertyIfNotEmpty(props, ConsumerConfig.CLIENT_ID_CONFIG, getClientId());
        addPropertyIfNotEmpty(props, ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, getFetchWaitMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METADATA_MAX_AGE_CONFIG, getMetadataMaxAgeMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRIC_REPORTER_CLASSES_CONFIG, getMetricReporters());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_NUM_SAMPLES_CONFIG, getNoOfMetricsSample());
        addPropertyIfNotEmpty(props, ConsumerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG, getMetricsSampleWindowMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG, getReconnectBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MS_CONFIG, getRetryBackoffMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RETRY_BACKOFF_MAX_MS_CONFIG, getRetryBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG, getReconnectBackoffMaxMs());
        addPropertyIfNotEmpty(props, ConsumerConfig.ISOLATION_LEVEL_CONFIG, getIsolationLevel());
        addPropertyIfNotEmpty(props, "schema.registry.url", getSchemaRegistryURL());
        addPropertyIfNotFalse(props, "specific.avro.reader", isSpecificAvroReader());

         
        if (sslContextParameters != null) {
            applySslConfigurationFromContext(props, sslContextParameters);
        } else {
            applySslConsumerConfigurationFromOptions(props);
        }

         
        addPropertyIfNotEmpty(props, CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, securityProtocol);

         
        if (isSasl(securityProtocol)) {
            applySaslConfiguration(props);
        }

         
        applyAdditionalProperties(props, getAdditionalProperties());

        return props;
    }

    private void processGetAllJobs(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String queryLocator = getParameter(QUERY_LOCATOR, exchange, IGNORE_BODY, IS_OPTIONAL);
        bulkClient.getAllJobs(queryLocator, determineHeaders(exchange),
                new BulkApiV2Client.JobsResponseCallback() {
                    @Override
                    public void onResponse(Jobs jobs, Map<String, String> headers, SalesforceException ex) {
                        BulkApiV2Processor.this.processResponse(exchange, jobs, headers, ex, callback);
                    }
                });
    }

    public void removeConsumer(String key, KameletConsumer consumer) {
        consumersLock.lock();
        try {
            consumers.remove(key, consumer);
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    public Exchange unmarshallExchange(CamelContext camelContext, ByteBuffer buffer, String deserializationFilter)
            throws IOException, ClassNotFoundException {
        DefaultExchangeHolder pe
                = (DefaultExchangeHolder) deserialize(camelContext, new ByteBufferInputStream(buffer), deserializationFilter);
        Exchange answer = new DefaultExchange(camelContext);
        DefaultExchangeHolder.unmarshal(answer, pe);
         
        String fromEndpointUri = (String) answer.removeProperty("CamelAggregatedFromEndpoint");
        if (fromEndpointUri != null) {
            Endpoint fromEndpoint = camelContext.hasEndpoint(fromEndpointUri);
            if (fromEndpoint != null) {
                answer.getExchangeExtension().setFromEndpoint(fromEndpoint);
            }
        }
        return answer;
    }

    public ProducerTemplate getObject() throws Exception {
        CamelContext context = getCamelContext();
        if (defaultEndpoint != null) {
            Endpoint endpoint = context.getEndpoint(defaultEndpoint);
            if (endpoint == null) {
                throw new IllegalArgumentException("No endpoint found for URI: " + defaultEndpoint);
            } else {
                template = new DefaultProducerTemplate(context, endpoint);
            }
        } else {
            template = new DefaultProducerTemplate(context);
        }

         
        if (maximumCacheSize != null) {
            template.setMaximumCacheSize(maximumCacheSize);
        }

         
        ServiceHelper.startService(template);
        return template;
    }

    public String dumpStatisticsAsJson() {
        ObjectWriter writer = mapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private void bulkUpdateUsers(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<UserRepresentation> users = exchange.getIn().getHeader(KeycloakConstants.USERS, List.class);
        if (users == null || users.isEmpty()) {
             
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof List) {
                users = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Users list must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (UserRepresentation user : users) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", user.getId());
            result.put("username", user.getUsername());
            try {
                if (ObjectHelper.isEmpty(user.getId())) {
                    throw new IllegalArgumentException("User ID is required for update operation");
                }
                keycloakClient.realm(realmName).users().get(user.getId()).update(user);
                result.put("status", "success");
                successCount++;
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to update user: " + user.getId(), e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", users.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    protected void doStart() throws Exception {
        super.doStart();

         
        PropertiesComponent pc = camelContext.getPropertiesComponent();
        PropertiesFunction pf = pc.getPropertiesFunction("configmap");
        if (pf instanceof ConfigMapPropertiesFunction) {
            propertiesFunction = (ConfigMapPropertiesFunction) pf;
            LOG.info("Auto-detecting configmaps from properties-function: {}", pf.getName());
        }
         
        configmaps = camelContext.getVaultConfiguration().kubernetesConfigmaps().getConfigmaps();
        if (ObjectHelper.isEmpty(configmaps) && propertiesFunction == null) {
            throw new IllegalArgumentException("Configmaps must be configured on Kubernetes configmaps vault configuration");
        }

        kubernetesClient = propertiesFunction.getClient();
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String topic = parseTopicName(entry.getUri());
        if (topic != null) {
            String originalTopic = parseTopicName(entry.getOriginalUri());
            if (!topic.equals(originalTopic)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, topic, originalTopic);
                return answer;
            }
        }
        return null;
    }

    public Exchange recover(CamelContext camelContext, final String exchangeId) {
        Exchange answer = null;

        try {
            byte[] completedLDBKey = keyBuilder(getRepositoryNameCompleted(), exchangeId);

            byte[] rc = levelDBFile.getDb().get(completedLDBKey);

            if (rc != null) {
                answer = codec().unmarshallExchange(camelContext, rc);
            }
        } catch (IOException e) {
            throw new RuntimeCamelException(
                    "Error recovering exchangeId " + exchangeId + " from repository " + repositoryName, e);
        }

        LOG.debug("Recovering exchangeId [{}] -> {}", exchangeId, answer);
        return answer;
    }

    private PullImageCmd executePullImageRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Pull Image Request");

        String repository = DockerHelper.getProperty(DockerConstants.DOCKER_REPOSITORY, configuration, message, String.class);

        ObjectHelper.notNull(repository, "Repository must be specified");

        PullImageCmd pullImageCmd = client.pullImageCmd(repository);

        String registry = DockerHelper.getProperty(DockerConstants.DOCKER_REGISTRY, configuration, message, String.class);
        if (registry != null) {
            pullImageCmd.withRegistry(registry);
        }

        String tag = DockerHelper.getProperty(DockerConstants.DOCKER_TAG, configuration, message, String.class);
        if (tag != null) {
            pullImageCmd.withTag(tag);
        }

        AuthConfig authConfig = client.authConfig();

        if (authConfig != null) {
            pullImageCmd.withAuthConfig(authConfig);
        }

        return pullImageCmd;

    }

    public String parseProperty(String key, String value, PropertiesLookup properties) {
        String answer = parser.parseProperty(key, value, properties);
        if (answer != null) {
            answer = springResolvePlaceholders(answer, properties);
        } else {
            answer = springResolvePlaceholders(value, properties);
        }
        return answer;
    }

        int asNum() {
            switch (this) {
                case LE:
                    return ComparisonTerm.LE;
                case LT:
                    return ComparisonTerm.LT;
                case EQ:
                    return ComparisonTerm.EQ;
                case NE:
                    return ComparisonTerm.NE;
                case GT:
                    return ComparisonTerm.GT;
                case GE:
                    return ComparisonTerm.GE;
                default:
                    throw new IllegalArgumentException("Unknown comparison " + this);
            }
        }

    protected void doStart() throws Exception {
        StringHelper.notEmpty(mapName, "repositoryName");
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }
        if (persistenceMapName == null) {
            persistenceMapName = String.format("%s%s", mapName, COMPLETED_SUFFIX);
        }
        if (hazelcastInstance == null) {
            useLocalHzInstance = true;
            Config cfg = new XmlConfigBuilder().build();
            cfg.setProperty("hazelcast.version.check.enabled", "false");
            hazelcastInstance = Hazelcast.newHazelcastInstance(cfg);
        } else {
            ObjectHelper.notNull(hazelcastInstance, "hazelcastInstance");
        }
        cache = hazelcastInstance.getMap(mapName);
        if (useRecovery) {
            persistedCache = hazelcastInstance.getMap(persistenceMapName);
        }
    }

    <T> Optional<T> tryToReadResponse(final Class<T> expectedType, final InputStream responseStream) {
        if (responseStream == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(fromJson(expectedType, responseStream));
        } catch (IOException e) {
            log.warn("Unable to read response from the Composite API", e);
            return Optional.empty();
        } finally {
            IOHelper.close(responseStream);
        }
    }

    public Integer export() throws Exception {
        String[] ids = gav.split(":");
        if (ids.length != 3) {
            printer().printErr("--gav must be in syntax: groupId:artifactId:version");
            return 1;
        }
        if (!buildTool.equals("maven") && !buildTool.equals("gradle")) {
            printer().printErr("--build-tool must either be maven or gradle, was: " + buildTool);
            return 1;
        }
        if (buildTool.equals("gradle")) {
            printer().println("WARN: --build-tool=gradle is deprecated.");
        }

        exportBaseDir = exportBaseDir != null ? exportBaseDir : Path.of(".");
        Path profile = exportBaseDir.resolve("application.properties");

         
        Path settings = CommandLineHelper.getWorkDir().resolve(Run.RUN_SETTINGS_FILE);
        if (fresh || !files.isEmpty() || !Files.exists(settings)) {
             
            printer().println("Generating fresh run data");
            int silent = runSilently(ignoreLoadingError, lazyBean, verbose);
            if (silent != 0) {
                return silent;
            }
        } else {
            printer().println("Reusing existing run data");
        }

        printer().println("Exporting as Quarkus project to: " + exportDir);

         
        Path buildDir = Path.of(BUILD_DIR);
        PathUtils.deleteDirectory(buildDir);
        Files.createDirectories(buildDir);

        Path srcJavaDirRoot = buildDir.resolve("src/main/java");
        String srcPackageName = exportPackageName(ids[0], ids[1], packageName);
        Path srcJavaDir;
        if (srcPackageName == null) {
            srcJavaDir = srcJavaDirRoot;
        } else {
            srcJavaDir = srcJavaDirRoot.resolve(srcPackageName.replace('.', File.separatorChar));
        }
        Files.createDirectories(srcJavaDir);
        Path srcResourcesDir = buildDir.resolve("src/main/resources");
        Files.createDirectories(srcResourcesDir);
        Path srcCamelResourcesDir = buildDir.resolve("src/main/resources/camel");
        Path srcKameletsResourcesDir = buildDir.resolve("src/main/resources/kamelets");
         
        copySourceFiles(settings, profile, srcJavaDirRoot, srcJavaDir,
                srcResourcesDir, srcCamelResourcesDir,
                srcKameletsResourcesDir, srcPackageName);
         
        copySettingsAndProfile(settings, profile, srcResourcesDir, prop -> {
            if (!hasModeline(settings)) {
                prop.remove("camel.main.modeline");
            }
             
            if (!prop.containsKey("quarkus.http.port")) {
                int port = httpServerPort(settings);
                if (port == -1) {
                    port = 8080;
                }
                if (port != 8080) {
                    prop.put("quarkus.http.port", port);
                }
            }
            if (!prop.containsKey("quarkus.management.port")) {
                port = httpManagementPort(settings);
                if (port != -1) {
                    prop.put("quarkus.management.port", port);
                }
            }
            if (hawtio) {
                prop.setProperty("quarkus.hawtio.authenticationEnabled", "false");
            }
            return prop;
        });
         
        copyDockerFiles(BUILD_DIR);
        String appJar = "target" + File.separator + "quarkus-app" + File.separator + "quarkus-run.jar";
        copyReadme(BUILD_DIR, appJar);
         
        Set<String> deps = resolveDependencies(settings, profile);
         
        copyLocalLibDependencies(deps);
        if ("maven".equals(buildTool)) {
            createMavenPom(settings, buildDir.resolve("pom.xml"), deps);
            if (mavenWrapper) {
                copyMavenWrapper();
            }
        } else if ("gradle".equals(buildTool)) {
            createGradleProperties(buildDir.resolve("gradle.properties"));
            createSettingsGradle(buildDir.resolve("settings.gradle"));
            createBuildGradle(settings, buildDir.resolve("build.gradle"), deps);
            if (gradleWrapper) {
                copyGradleWrapper();
            }
        }

        if (cleanExportDir || !exportDir.equals(".")) {
             
             
            CommandHelper.cleanExportDir(exportDir);
        }
         
        PathUtils.copyDirectory(buildDir, Path.of(exportDir));
        PathUtils.deleteDirectory(buildDir);

        return 0;
    }

    public static void findXmlRouters(Set<File> xmlFiles, boolean includeXml, boolean includeTest, MavenProject project) {
        if (includeXml) {
            for (Resource dir : project.getResources()) {
                findXmlFiles(new File(dir.getDirectory()), xmlFiles);
            }
            if (includeTest) {
                for (Resource dir : project.getTestResources()) {
                    findXmlFiles(new File(dir.getDirectory()), xmlFiles);
                }
            }
        }
    }

    private RestartContainerCmd executeRestartContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Restart Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        RestartContainerCmd restartContainerCmd = client.restartContainerCmd(containerId);

        Integer timeout = DockerHelper.getProperty(DockerConstants.DOCKER_TIMEOUT, configuration, message, Integer.class);

        if (timeout != null) {
            restartContainerCmd.withtTimeout(timeout);
        }

        return restartContainerCmd;

    }

    public Producer createProducer() throws Exception {
        if (metricsType == MetricsType.COUNTER) {
            return new CounterProducer(this);
        } else if (metricsType == MetricsType.HISTOGRAM) {
            return new HistogramProducer(this);
        } else if (metricsType == MetricsType.METER) {
            return new MeterProducer(this);
        } else if (metricsType == MetricsType.TIMER) {
            return new TimerProducer(this);
        } else if (metricsType == MetricsType.GAUGE) {
            return new GaugeProducer(this);
        } else {
            throw new IllegalArgumentException("Metrics type " + metricsType + " is not supported");
        }
    }

    protected void doStop() throws Exception {
        ServiceHelper.stopService(map);

        if (scheduledExecutorService != null && stopScheduledExecutorService) {
            camelContext.getExecutorServiceManager().shutdown(scheduledExecutorService);
            scheduledExecutorService = null;
        }
        if (workerPool != null && stopWorkerPool) {
            camelContext.getExecutorServiceManager().shutdown(workerPool);
            workerPool = null;
        }
    }

    private void createMavenPom(Path settings, Path pom, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        InputStream is = ExportQuarkus.class.getClassLoader().getResourceAsStream("templates/" + pomTemplateName);
        String context = IOHelper.loadText(is);
        IOHelper.close(is);

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
         
        String repos = getMavenRepositories(settings, prop, quarkusVersion);

        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(repos, quarkusVersion, quarkusGroupId, download);
        if (camelVersion == null) {
            camelVersion = catalog.getCatalogVersion();
        }

        String mp = prop.getProperty("quarkus.management.port");
        if (mp == null) {
            mp = "9876";
        }

        context = context.replaceAll("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceAll("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceAll("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.QuarkusGroupId }}", quarkusGroupId);
        context = context.replaceAll("\\{\\{ \\.QuarkusArtifactId }}", quarkusArtifactId);
        context = context.replaceAll("\\{\\{ \\.QuarkusVersion }}", quarkusVersion);
        context = context.replaceAll("\\{\\{ \\.QuarkusManagementPort }}", mp);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceAll("\\{\\{ \\.ProjectBuildOutputTimestamp }}", this.getBuildMavenProjectDate());

        context = replaceBuildProperties(context);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            String s = mavenRepositoriesAsPomXml(repos);
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", s);
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();
             
            if ("org.apache.camel".equals(gid)) {
                String qaid = aid.replace("camel-", "camel-quarkus-");
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.quarkus", qaid, null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        replaceQuarkusDependencies(gavs);

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
             
            if ("camel-quarkus-core".equals(gav.getArtifactId())
                    || "camel-quarkus-microprofile-health".equals(gav.getArtifactId())) {
                continue;
            }
            sb.append("        <dependency>\n");
            sb.append("            <groupId>").append(gav.getGroupId()).append("</groupId>\n");
            sb.append("            <artifactId>").append(gav.getArtifactId()).append("</artifactId>\n");
            if (gav.getVersion() != null) {
                sb.append("            <version>").append(gav.getVersion()).append("</version>\n");
            }
            if (gav.getScope() != null) {
                sb.append("            <scope>").append(gav.getScope()).append("</scope>\n");
            }
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("            <scope>system</scope>\n");
                sb.append("            <systemPath>\\$\\{project.basedir}/lib/").append(gav.getArtifactId()).append("-")
                        .append(gav.getVersion()).append(".jar</systemPath>\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("            <exclusions>\n");
                sb.append("                <exclusion>\n");
                sb.append("                    <groupId>org.apache.camel</groupId>\n");
                sb.append("                    <artifactId>*</artifactId>\n");
                sb.append("                </exclusion>\n");
                sb.append("            </exclusions>\n");
            }
            sb.append("        </dependency>\n");
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        Files.writeString(pom, context);
    }

    protected TrustManagersParameters createInstance() throws Exception {
        TrustManagersParameters newInstance = new TrustManagersParameters();

        newInstance.setAlgorithm(algorithm);
        if (getKeyStore() != null) {
            getKeyStore().setCamelContext(getCamelContext());
            newInstance.setKeyStore(getKeyStore().getObject());
        }
        newInstance.setProvider(provider);
        newInstance.setCamelContext(getCamelContext());

        if (trustManager != null) {
            TrustManager tm = CamelContextHelper.mandatoryLookup(getCamelContext(), trustManager, TrustManager.class);
            newInstance.setTrustManager(tm);
        }

        return newInstance;
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("alias", alias);
        if (aliasImplementation != null) {
            jo.put("aliasImplementation", aliasImplementation);
        }
        if (description != null) {
            jo.put("description", description);
        }
        if (serviceData != null) {
            jo.put("serviceData", serviceData);
        }
        return jo;
    }

    private void modifyRecord(Exchange exchange) throws Exception {
        final Message in = exchange.getIn();
        final String tableName = getTableName(in);
        final String apiVersion = getApiVersion(in);
        final Class<?> requestModel = getRequestModel(in, tableName);
        final Class<?> responseModel = getResponseModel(in, tableName);
        final String sysId = getSysID(in);

        validateBody(in, requestModel);

        Response response = client.reset()
                .types(MediaType.APPLICATION_JSON_TYPE)
                .path("now")
                .path(apiVersion)
                .path("table")
                .path(tableName)
                .path(ObjectHelper.notNull(sysId, "sysId"))
                .query(ServiceNowParams.SYSPARM_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_EXCLUDE_REFERENCE_LINK, in)
                .query(ServiceNowParams.SYSPARM_FIELDS, in)
                .query(ServiceNowParams.SYSPARM_INPUT_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_SUPPRESS_AUTO_SYS_FIELD, in)
                .query(ServiceNowParams.SYSPARM_VIEW, in)
                .query(responseModel)
                .invoke(HttpMethod.PUT, in.getMandatoryBody());

        setBodyAndHeaders(exchange.getIn(), responseModel, response);
    }

    protected Set<FieldInfo> fields(ClassInfo ci) {
        Set<FieldInfo> fields = new TreeSet<>(Comparator.comparing(FieldInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            fields.addAll(current.fields());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return fields;
    }

    public static Stream<Path> walk(Path rootDir) {
        try {
            if (Files.isDirectory(rootDir)) {
                return Files.walk(rootDir);
            } else {
                return Stream.empty();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public int processBatch(Queue<Object> exchanges) {
        final int total = exchanges.size();

        for (int i = 0; i < total && isBatchAllowed(); i++) {
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());

            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, i);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, i == total - 1);

            pendingExchanges = total - i - 1;

            exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                @Override
                public void onComplete(Exchange exchange) {
                    LOG.trace("Processing all exchanges completed");
                }

                @Override
                public void onFailure(Exchange exchange) {
                    processRollback(exchange);
                }
            });
             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
        }

        return total;
    }

    public static int compare(String source, String target) {
        if (source == null || target == null) {
            return 0;
        }
        String s1 = StringHelper.before(source, ".");
        String s2 = StringHelper.after(source, ".");
        if (s1 == null) {
            s1 = StringHelper.before(source, ",");
            s2 = StringHelper.after(source, ",");
        }
        String t1 = StringHelper.before(target, ".");
        String t2 = StringHelper.after(target, ".");
        if (t1 == null) {
            t1 = StringHelper.before(target, ",");
            t2 = StringHelper.after(target, ",");
        }
        String s3 = StringHelper.after(s2, ".");
        if (s3 != null) {
            s2 = StringHelper.before(s2, ".");
        } else {
            s3 = "";
        }
        String t3 = StringHelper.after(t2, ".");
        if (t3 != null) {
            t2 = StringHelper.before(t2, ".");
        } else {
            t3 = "";
        }
         
        if (s1 == null) {
            s1 = source;
        }
        if (s2 == null) {
            s2 = "";
        }
        if (t1 == null) {
            t1 = target;
        }
        if (t2 == null) {
            t2 = "";
        }
         
        if (s1.length() < 2) {
            s1 = "0" + s1;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s3.length() < 2) {
            s3 = "0" + s3;
        }
        if (t1.length() < 2) {
            t1 = "0" + t1;
        }
        if (t2.length() < 2) {
            t2 = "0" + t2;
        }
        if (t3.length() < 2) {
            t3 = "0" + t3;
        }

        String s = s1 + s2 + s3;
        String t = t1 + t2 + t3;
        return s.compareTo(t);
    }

    protected SubmitSm[] createSubmitSm(Exchange exchange) throws SmppException {
        Message message = exchange.getIn();
        SubmitSm template = createSubmitSmTemplate(exchange);
        byte[][] segments = splitBody(message);

         
        ESMClass esmClass = message.getHeader(SmppConstants.ESM_CLASS, ESMClass.class);
        if (esmClass != null) {
            template.setEsmClass(esmClass.value());
        } else if (segments.length > 1) {
             
            template.setEsmClass(new ESMClass(MessageMode.DEFAULT, MessageType.DEFAULT, GSMSpecificFeature.UDHI).value());
        }

        SubmitSm[] submitSms = new SubmitSm[segments.length];
        for (int i = 0; i < segments.length; i++) {
            SubmitSm submitSm = SmppUtils.copySubmitSm(template);
            submitSm.setShortMessage(segments[i]);
            submitSms[i] = submitSm;
        }
        setRegisterDeliveryReceiptFlag(submitSms, message);
        return submitSms;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, byte[].class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toByteArray((ca.uhn.hl7v2.model.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((byte[]) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toString((ca.uhn.hl7v2.model.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private static Map<String, Object> checkValidExchangePropertyObjects(
            String type, Exchange exchange, Map<String, Object> map, boolean allowSerializedValues) {
        if (map == null) {
            return null;
        }

        Map<String, Object> result = new LinkedHashMap<>();
        for (Map.Entry<String, Object> entry : map.entrySet()) {

             
            if (entry.getValue() == null) {
                continue;
            }

            Object value = getValidExchangePropertyValue(entry.getKey(), entry.getValue(), allowSerializedValues);
            if (value != null) {
                Serializable converted
                        = exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, value);
                if (converted != null) {
                    result.put(entry.getKey(), converted);
                } else {
                    logCannotSerializeObject(type, entry.getKey(), entry.getValue());
                }
            } else {
                logInvalidExchangePropertyValue(type, entry.getKey(), entry.getValue());
            }
        }

        return result;
    }

        public Olingo2BatchChangeRequest build() {
             
            if (request.resourcePath == null) {
                throw new IllegalArgumentException("Null resourcePath");
            }
            if (request.operation == null) {
                throw new IllegalArgumentException("Null operation");
            }
            if (request.operation != Operation.DELETE && request.body == null) {
                throw new IllegalArgumentException("Null body");
            }
            return request;
        }

    public Service newHttpManagementServer(
            CamelContext camelContext, HttpManagementServerConfigurationProperties configuration) {
        ManagementHttpServer server = new ManagementHttpServer();

        server.setCamelContext(camelContext);
        server.setHost(configuration.getHost());
        server.setPort(configuration.getPort());
        server.setPath(configuration.getPath());

        server.setUseGlobalSslContextParameters(configuration.isUseGlobalSslContextParameters());
        server.setInfoEnabled(configuration.isInfoEnabled());
        server.setDevConsoleEnabled(configuration.isDevConsoleEnabled());
        server.setHealthCheckEnabled(configuration.isHealthCheckEnabled());
        server.setHealthPath(configuration.getHealthPath());
        server.setInfoPath(configuration.getInfoPath());
        server.setJolokiaEnabled(configuration.isJolokiaEnabled());
        server.setJolokiaPath(configuration.getJolokiaPath());
        server.setMetricsEnabled(configuration.isMetricsEnabled());
        server.setUploadEnabled(configuration.isUploadEnabled());
        server.setUploadSourceDir(configuration.getUploadSourceDir());
        server.setDownloadEnabled(configuration.isDownloadEnabled());
        server.setSendEnabled(configuration.isSendEnabled());

        if (configuration.isAuthenticationEnabled()) {
            configureAuthentication(server, configuration);
        }

        return server;
    }

    private void getModel(Exchange exchange) {
        SpeechToText stt = getEndpoint().getSttClient();
        if (stt == null) {
            throw new IllegalStateException("STT client not initialized");
        }

        String modelName = exchange.getIn().getHeader(WatsonSpeechToTextConstants.MODEL_NAME, String.class);
        if (modelName == null) {
            modelName = exchange.getIn().getBody(String.class);
        }

        if (modelName == null || modelName.isBlank()) {
            throw new IllegalArgumentException("Model name must be specified");
        }

        LOG.trace("Getting model information for: {}", modelName);

        GetModelOptions options = new GetModelOptions.Builder()
                .modelId(modelName)
                .build();

        SpeechModel model = stt.getModel(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(model);
    }

    public Set<Class<?>> findImplementations(Class<?> parent, String... packageNames) {
        if (packageNames == null) {
            return Collections.emptySet();
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Searching for implementations of {} in packages: {}", parent.getName(), Arrays.asList(packageNames));
        }

        PackageScanFilter test = getCompositeFilter(new AssignableToPackageScanFilter(parent));
        Set<Class<?>> classes = new LinkedHashSet<>();
        for (String pkg : packageNames) {
            find(test, pkg, classes);
        }

        LOG.debug("Found: {}", classes);

        return classes;
    }

    public void setDataObjectFormatIdentifierDocumentationReferences(
            List<String> dataObjectFormatIdentifierDocumentationReferences) {
        if (dataObjectFormatIdentifierDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'dataObjectFormatIdentifierDocumentationReferences' is null");
        }
        for (String ref : dataObjectFormatIdentifierDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one reference of the identifier of the data object format is null or empty");
            }
        }
        this.dataObjectFormatIdentifierDocumentationReferences
                = new ArrayList<>(dataObjectFormatIdentifierDocumentationReferences);
    }

    protected void doListServiceByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_LABELS, Map.class);
        ServiceList servicesList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing Services by labels requires specifying labels");
            throw new IllegalArgumentException("Listing Services by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            servicesList = getEndpoint().getKubernetesClient().services().inAnyNamespace().withLabels(labels).list();
        } else {
            servicesList = getEndpoint().getKubernetesClient().services().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, servicesList.getItems());
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Object oid = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_ID)) {
            oid = headers.get(HazelcastConstants.OBJECT_ID);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {
            case PUT:
                this.put(oid, exchange);
                break;

            case GET:
                this.get(oid, exchange);
                break;

            case DELETE:
                this.delete(oid);
                break;

            case REMOVE_VALUE:
                this.removevalue(oid, exchange);
                break;

            case CONTAINS_KEY:
                this.containsKey(oid, exchange);
                break;

            case CONTAINS_VALUE:
                this.containsValue(exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case VALUE_COUNT:
                this.valuecount(oid, exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the MULTIMAP cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    private void processGetBlobField(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
         
        final String sObjectBlobFieldName = getParameter(SOBJECT_BLOB_FIELD_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        String sObjectId = determineSObjectId(exchange);

        restClient.getBlobField(sObjectName, sObjectId, sObjectBlobFieldName, determineHeaders(exchange),
                new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, sObjectId, null, null);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ConfigMapList configMapsList;

        if (ObjectHelper.isEmpty(namespace)) {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace().list();
        } else {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, configMapsList.getItems());
    }

    public void setMessageGroupIdStrategy(String strategy) {
        if ("useConstant".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new ConstantMessageGroupIdStrategy();
        } else if ("useExchangeId".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new ExchangeIdMessageGroupIdStrategy();
        } else if ("usePropertyValue".equalsIgnoreCase(strategy)) {
            messageGroupIdStrategy = new PropertyValueMessageGroupIdStrategy();
        } else {
            throw new IllegalArgumentException("Unrecognised MessageGroupIdStrategy: " + strategy);
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {

        if (remaining == null || remaining.isBlank()) {
            throw new IllegalArgumentException("At least the account name must be specified.");
        }

        final BlobConfiguration config = this.configuration != null ? this.configuration.copy() : new BlobConfiguration();

        final String[] parts = remaining.split("/");

         
        config.setAccountName(parts[0]);

         
        if (parts.length > 1) {
            config.setContainerName(parts[1]);
        }

        final BlobEndpoint endpoint = new BlobEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

        initCredentialConfig(config);
        validateConfigurations(config);

        return endpoint;
    }

    private String getUserMessageText(Exchange exchange) {
        String userMessageText = exchange.getIn().getHeader(SpringAiChatConstants.USER_MESSAGE, String.class);
        if (userMessageText == null) {
            userMessageText = getEndpoint().getConfiguration().getUserMessage();
        }
        if (userMessageText == null) {
            userMessageText = "";  
        }
        return userMessageText;
    }

    private static String detectMimeTypeFromExtension(String fileName) {
        String lowerName = fileName.toLowerCase();

         
        if (lowerName.endsWith(".png")) {
            return "image/png";
        } else if (lowerName.endsWith(".jpg") || lowerName.endsWith(".jpeg")) {
            return "image/jpeg";
        } else if (lowerName.endsWith(".gif")) {
            return "image/gif";
        } else if (lowerName.endsWith(".webp")) {
            return "image/webp";
        } else if (lowerName.endsWith(".bmp")) {
            return "image/bmp";
        } else if (lowerName.endsWith(".tiff") || lowerName.endsWith(".tif")) {
            return "image/tiff";
        } else if (lowerName.endsWith(".svg")) {
            return "image/svg+xml";
        }
         
        else if (lowerName.endsWith(".mp4")) {
            return "video/mp4";
        } else if (lowerName.endsWith(".webm")) {
            return "video/webm";
        } else if (lowerName.endsWith(".mov")) {
            return "video/quicktime";
        } else if (lowerName.endsWith(".mkv")) {
            return "video/x-matroska";
        } else if (lowerName.endsWith(".avi")) {
            return "video/x-msvideo";
        }
         
        else if (lowerName.endsWith(".wav")) {
            return "audio/wav";
        } else if (lowerName.endsWith(".mp3")) {
            return "audio/mpeg";
        } else if (lowerName.endsWith(".ogg")) {
            return "audio/ogg";
        } else if (lowerName.endsWith(".m4a")) {
            return "audio/mp4";
        } else if (lowerName.endsWith(".flac")) {
            return "audio/flac";
        }
         
        else if (lowerName.endsWith(".pdf")) {
            return "application/pdf";
        }
         
        else if (lowerName.endsWith(".txt")) {
            return "text/plain";
        } else if (lowerName.endsWith(".csv")) {
            return "text/csv";
        } else if (lowerName.endsWith(".html") || lowerName.endsWith(".htm")) {
            return "text/html";
        } else if (lowerName.endsWith(".md")) {
            return "text/markdown";
        } else if (lowerName.endsWith(".xml")) {
            return "text/xml";
        } else if (lowerName.endsWith(".json")) {
            return "application/json";
        }

        LOG.warn("Could not detect MIME type from file extension: {}. Please set the CamelLangChain4jAgentMediaType header.",
                fileName);
        throw new IllegalArgumentException(
                "Cannot determine MIME type for file: " + fileName
                                           + ". Please set the CamelLangChain4jAgentMediaType header.");
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(PahoMqtt5Constants.CAMEL_PAHO_OVERRIDE_TOPIC) != null) {
            return null;
        }

        final String destinationName = parseTopicName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getMessage().setHeader(PahoMqtt5Constants.CAMEL_PAHO_OVERRIDE_TOPIC, destinationName);
            }
        };
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        PersistentVolumeClaimList pvcList;

        if (ObjectHelper.isEmpty(namespace)) {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inAnyNamespace().list();
        } else {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, pvcList.getItems());
    }

    protected void doStart() throws Exception {
        super.doStart();

        connectionOptions = getEndpoint().createMqttConnectionOptions();

        if (client == null) {
            clientId = getEndpoint().getConfiguration().getClientId();
            if (clientId == null) {
                clientId = PahoMqtt5Endpoint.generateClientId();
            }
            stopClient = true;
            client = new MqttClient(
                    getEndpoint().getConfiguration().getBrokerUrl(),
                    clientId,
                    PahoMqtt5Endpoint.createMqttClientPersistence(getEndpoint().getConfiguration()));
            LOG.debug("Connecting client: {} to broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            if (getEndpoint().getConfiguration().isManualAcksEnabled()) {
                client.setManualAcks(true);

            }
            client.connect(connectionOptions);
        }

        client.setCallback(new MqttCallback() {

            @Override
            public void connectComplete(boolean reconnect, String serverURI) {
                if (reconnect) {
                    try {
                        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
                    } catch (MqttException e) {
                        LOG.error("MQTT resubscribe failed {}", e.getMessage(), e);
                    }
                }
            }

            @Override
            public void authPacketArrived(int reasonCode, MqttProperties properties) {
                LOG.debug("Auth packet arrived {} {}", reasonCode, properties);
            }

            @Override
            public void disconnected(MqttDisconnectResponse response) {
                LOG.debug("MQTT broker disconnected due {}", response.getReasonString(), response.getException());
            }

            @Override
            public void mqttErrorOccurred(MqttException exception) {
                LOG.debug("Error occurred {}", exception.getMessage(), exception);
            }

            @Override
            public void messageArrived(String topic, MqttMessage message) throws Exception {
                LOG.debug("Message arrived on topic: {} -> {}", topic, message);
                Exchange exchange = createExchange(message, topic);

                 
                AsyncCallback cb = defaultConsumerCallback(exchange, true);
                getAsyncProcessor().process(exchange, cb);
            }

            @Override
            public void deliveryComplete(IMqttToken token) {
                LOG.debug("Delivery complete. Token: {}", token);
            }
        });

        LOG.debug("Subscribing client: {} to topic: {}", clientId, getEndpoint().getTopic());
        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
    }

    public E predecessor(E e) {
        E elem = lower(e);
        if (elem == null) {
            return null;
        }
        if (seqComparator().predecessor(elem, e)) {
            return elem;
        }
        return null;
    }

    private long determineWaitTimeout(final Exchange exchange, Athena2Configuration configuration) {
        Long waitTimeout = exchange.getIn().getHeader(Athena2Constants.WAIT_TIMEOUT, Long.class);

        if (ObjectHelper.isEmpty(waitTimeout)) {
            waitTimeout = configuration.getWaitTimeout();
            LOG.trace("AWS Athena wait timeout is missing, using default one [{}]", waitTimeout);
        }

        if (ObjectHelper.isEmpty(waitTimeout)) {
            throw new IllegalArgumentException("AWS Athena wait timeout required.");
        }

        if (waitTimeout < 0) {
            throw new IllegalArgumentException("AWS Athena wait timeout must be >= 0");
        }

        return waitTimeout;
    }

    private void stopConsumer(Route route) {
        lock.lock();
        try {
            if (!suspendedRoutes.contains(route)) {
                LOGGER.debug("Stopping consumer for {} ({})", route.getId(), route.getConsumer());
                stopConsumer(route.getConsumer());
                suspendedRoutes.add(route);
            }
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public static void registerDownloadReifiers(KameletMain main) {
        ProcessorReifier.registerReifier(TransactedDefinition.class,
                (route, processorDefinition) -> {
                    if (processorDefinition instanceof TransactedDefinition) {
                        DependencyDownloader downloader = route.getCamelContext().hasService(DependencyDownloader.class);
                        if (downloader != null) {
                            downloader.downloadDependency("org.apache.camel", "camel-jta",
                                    route.getCamelContext().getVersion());
                            TransactedPolicy policy = new DummyTransactedPolicy();
                            Arrays.stream(TRANSACTED_POLICIES).forEach(p -> main.bind(p, policy));
                        }
                    }
                    return ProcessReifier.coreReifier(route, processorDefinition);
                });
    }

    public <T> T receiveBody(String endpointUri, Class<T> type) {
        Object answer;
        Exchange exchange = receive(endpointUri);
        try {
            answer = extractResultBody(exchange);
            answer = camelContext.getTypeConverter().convertTo(type, exchange, answer);
        } finally {
            doneUoW(exchange);
        }
        return (T) answer;
    }

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Failover).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    private void addDocument(Exchange exchange) {
        Discovery discovery = getEndpoint().getDiscoveryClient();
        String projectId = getEndpoint().getConfiguration().getProjectId();

        String collectionId = exchange.getIn().getHeader(WatsonDiscoveryConstants.COLLECTION_ID, String.class);
        if (collectionId == null) {
            collectionId = getEndpoint().getConfiguration().getCollectionId();
        }

        if (collectionId == null) {
            throw new IllegalArgumentException("Collection ID must be specified");
        }

        InputStream file = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_FILE, InputStream.class);
        if (file == null) {
            file = exchange.getIn().getBody(InputStream.class);
        }

        if (file == null) {
            throw new IllegalArgumentException("Document file must be specified");
        }

        String filename = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_FILENAME, String.class);
        if (filename == null) {
            filename = "document";
        }

        String contentType = exchange.getIn().getHeader(WatsonDiscoveryConstants.DOCUMENT_CONTENT_TYPE, String.class);
        if (contentType == null) {
            contentType = "application/octet-stream";
        }

        LOG.trace("Adding document to collection: {}", collectionId);

        AddDocumentOptions options = new AddDocumentOptions.Builder()
                .projectId(projectId)
                .collectionId(collectionId)
                .file(file)
                .filename(filename)
                .fileContentType(contentType)
                .build();

        DocumentAccepted result = discovery.addDocument(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        message.setHeader(WatsonDiscoveryConstants.DOCUMENT_ID, result.getDocumentId());
    }

    private Queue<Exchange> pollAdminEvents() throws Exception {
        Keycloak keycloakClient = getEndpoint().getKeycloakClient();
        KeycloakConfiguration config = getEndpoint().getConfiguration();
        String realm = config.getRealm();

        if (realm == null) {
            throw new IllegalArgumentException("Realm must be specified for consuming admin events");
        }

         
         
         
        List<String> adminOperationTypes = parseCommaSeparatedList(config.getOperationTypes());
        List<AdminEventRepresentation> adminEvents = keycloakClient.realm(realm).getAdminEvents(
                adminOperationTypes,  
                config.getAuthRealmFilter(),  
                config.getAuthClient(),  
                config.getAuthUser(),  
                config.getAuthIpAddress(),  
                config.getResourcePath(),  
                config.getDateFrom(),  
                config.getDateTo(),  
                config.getFirst(),  
                config.getMaxResults()  
        );

        Queue<Exchange> queue = new LinkedList<>();
        long highestEventTime = lastEventTime != null ? lastEventTime : 0;

        for (AdminEventRepresentation adminEvent : adminEvents) {
            long eventTime = adminEvent.getTime();

             
            if (lastEventTime != null && eventTime < lastEventTime) {
                continue;
            }

             
            String fingerprint = getAdminEventFingerprint(adminEvent);

             
            if (processedEventFingerprints.contains(fingerprint)) {
                LOG.trace("Skipping already processed admin event: {}", fingerprint);
                continue;
            }

            Exchange exchange = createExchange(false);
            exchange.getIn().setBody(adminEvent);
            exchange.getIn().setHeader(KeycloakConstants.EVENT_TYPE, "admin-event");
            exchange.getIn().setHeader(KeycloakConstants.EVENT_ID, adminEvent.getTime());
            exchange.getIn().setHeader(KeycloakConstants.REALM_NAME, realm);
            queue.add(exchange);

             
            processedEventFingerprints.add(fingerprint);

             
            if (eventTime > highestEventTime) {
                highestEventTime = eventTime;
            }

             
            if (processedEventFingerprints.size() > MAX_FINGERPRINT_CACHE_SIZE) {
                 
                 
                processedEventFingerprints.clear();
                LOG.debug("Cleared fingerprint cache due to size limit");
            }
        }

         
        if (highestEventTime > (lastEventTime != null ? lastEventTime : 0)) {
             
            processedEventFingerprints.clear();
            lastEventTime = highestEventTime;
            LOG.debug("Updated last admin event time to: {}", lastEventTime);
        }

        return queue;
    }

    private Olingo4ApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<Olingo4ApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(Olingo4ApiName.class);
        final Map<Class<? extends ApiMethod>, Olingo4ApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList("queryParams", "endpointHttpHeaders", "edm", "responseHandler", "data");
        apiHelpers.put(Olingo4ApiName.DEFAULT, new ApiMethodHelper<>(Olingo4AppApiMethod.class, aliases, nullableArgs));
        apiMethods.put(Olingo4AppApiMethod.class, Olingo4ApiName.DEFAULT);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public JobResponse updateJobRetries(JobRequest message) {
        JobResponse resultMessage = new JobResponse();

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.UpdateJobRetriesRequest.Builder builder = GatewayOuterClass.UpdateJobRetriesRequest.newBuilder()
                    .setJobKey(message.getJobKey());
            builder = builder.setRetries(message.getRetries());
            GatewayOuterClass.UpdateJobRetriesRequest request = builder.build();
            GatewayOuterClass.UpdateJobRetriesResponse updateJobRetriesResponse = stub.updateJobRetries(request);

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot update retries for Job %s", message.getJobKey()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();
        int answer = total;
        if (this.maxMessagesPerPoll > 0 && total > this.maxMessagesPerPoll) {
            LOG.debug("Limiting to maximum messages to poll {} as there were {} messages in this poll.",
                    this.maxMessagesPerPoll, total);
            total = this.maxMessagesPerPoll;
        }

        for (int index = 0; index < total && this.isBatchAllowed(); ++index) {
            Exchange exchange = (Exchange) exchanges.poll();
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);
            this.pendingExchanges = total - index - 1;
            getProcessor().process(exchange);
        }

        return answer;
    }

    private Exception createExceptionFromFault(String soapAction, Fault fault) {
        StringBuilder sb = new StringBuilder();
        for (Reasontext text : fault.getReason().getText()) {
            sb.append(text.getValue());
        }
        String message = sb.toString();

        Detail faultDetail = fault.getDetail();
        if (faultDetail == null || faultDetail.getAny().isEmpty()) {
            try {
                return new SOAPFaultException(SOAPFactory.newInstance().createFault(message, fault.getCode().getValue()));
            } catch (SOAPException e) {
                throw new RuntimeCamelException(e);
            }
        }

        Object detailObj = faultDetail.getAny().get(0);

        if (!(detailObj instanceof JAXBElement)) {
            try {
                return new SOAPFaultException(SOAPFactory.newInstance().createFault(message, fault.getCode().getValue()));
            } catch (SOAPException e) {
                throw new RuntimeCamelException(e);
            }
        }

        JAXBElement<?> detailEl = (JAXBElement<?>) detailObj;
        Class<? extends Exception> exceptionClass
                = getDataFormat().getElementNameStrategy().findExceptionForSoapActionAndFaultName(soapAction,
                        detailEl.getName());
        Constructor<? extends Exception> messageConstructor;
        Constructor<? extends Exception> constructor;

        try {
            Object detail = JAXBIntrospector.getValue(detailEl);
            try {
                constructor = exceptionClass.getConstructor(String.class, detail.getClass());
                return constructor.newInstance(message, detail);
            } catch (NoSuchMethodException e) {
                messageConstructor = exceptionClass.getConstructor(String.class);
                return messageConstructor.newInstance(message);
            }
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public String dumpStatisticsAsJson() {
        ObjectWriter writer = mapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public FluentProducerTemplate withHeaders(Map<String, Object> headers) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException("Cannot use both withHeaders and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.headers;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.headers = map;
        }
        map.putAll(headers);
        return clone;
    }

    public void onStart(Route route) {
         
        statisticsMap.computeIfAbsent(route,
                it -> {
                    boolean skip = !configuration.isRouteEnabled();
                     
                    if (!skip) {
                        skip = (it.isCreatedByKamelet() && !registerKamelets)
                                || (it.isCreatedByRouteTemplate() && !registerTemplates);
                    }
                    if (!skip && configuration.getExcludePattern() != null) {
                        String[] patterns = configuration.getExcludePattern().split(",");
                        skip = PatternHelper.matchPatterns(route.getRouteId(), patterns);
                    }
                    LOG.debug("Capturing metrics for route: {} -> {}", route.getRouteId(), skip);
                    if (skip) {
                        return null;
                    }
                    return new MetricsStatistics(
                            meter, it.getCamelContext(), it, getNamingStrategy(), configuration, timeUnit, longTaskTimeUnit);
                });
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
         
        if (remaining.startsWith("DEFAULT/")) {
            remaining = remaining.substring(8);
        }
        final String[] pathSegments = remaining.split("/", -1);
        final String methodName = pathSegments[0];

        if (pathSegments.length > 1) {
            final StringBuilder resourcePath = new StringBuilder();
            for (int i = 1; i < pathSegments.length; i++) {
                resourcePath.append(pathSegments[i]);
                if (i < (pathSegments.length - 1)) {
                    resourcePath.append('/');
                }
            }
             
            parameters.put(Olingo4Endpoint.RESOURCE_PATH_PROPERTY, resourcePath.toString());
        }

        final Olingo4Configuration endpointConfiguration = createEndpointConfiguration(Olingo4ApiName.DEFAULT);
        final Endpoint endpoint = createEndpoint(uri, methodName, Olingo4ApiName.DEFAULT, endpointConfiguration);

         
        setProperties(endpoint, parameters);

        return endpoint;
    }

    public Integer doCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        if (pids.isEmpty()) {
            return 0;
        } else if (pids.size() > 1) {
            printer().println("Name or pid " + name + " matches " + pids.size()
                              + " running Camel integrations. Specify a name or PID that matches exactly one.");
            return 0;
        }

        this.pid = pids.get(0);

         
        Path outputFile = getOutputFile(Long.toString(pid));
        PathUtils.deleteFile(outputFile);

        JsonObject root = new JsonObject();
        root.put("action", "route-dump");
        root.put("filter", "*");
        root.put("format", format);
        root.put("uriAsParameters", uriAsParameters);
        Path file = getActionFile(Long.toString(pid));
        try {
            Files.writeString(file, root.toJson());
        } catch (Exception e) {
             
        }

        JsonObject jo = waitForOutputFile(outputFile);
        if (jo != null) {
            JsonArray arr = (JsonArray) jo.get("routes");
            for (int i = 0; i < arr.size(); i++) {
                JsonObject o = (JsonObject) arr.get(i);
                Row row = new Row();
                row.location = extractSourceName(o.getString("source"));
                row.routeId = o.getString("routeId");
                if (!rows.contains(row)) {
                    List<JsonObject> lines = o.getCollection("code");
                    if (lines != null) {
                        for (JsonObject line : lines) {
                            Code code = new Code();
                            code.line = line.getInteger("line");
                            code.code = line.getString("code");
                            row.code.add(code);
                        }
                    }
                    boolean add = true;
                    if (filter != null) {
                        String f = filter;
                        boolean negate = filter.startsWith("-");
                        if (negate) {
                            f = f.substring(1);
                        }
                         
                        if (!f.endsWith("*")) {
                            f += "*";
                        }
                        boolean match
                                = PatternHelper.matchPattern(row.location, f) || PatternHelper.matchPattern(row.routeId, f);
                        if (negate) {
                            match = !match;
                        }
                        if (!match) {
                            add = false;
                        }
                    }
                    if (add) {
                        rows.add(row);
                    }
                }
            }
        } else {
            printer().println("Response from running Camel with PID " + pid + " not received within 5 seconds");
            return 1;
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printSource(rows);
        }

         
        PathUtils.deleteFile(outputFile);

        return 0;
    }

    protected void ensureNamespacesCapacity(int size) {
        final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
        if (size >= namespaceSize) {
            final int newSize = size > 7 ? 2 * size : 8;  
            if (TRACE_SIZING) {
                System.err.println("TRACE_SIZING namespaceSize " + namespaceSize + " ==> " + newSize);
            }
            final String[] newNamespacePrefix = new String[newSize];
            final String[] newNamespaceUri = new String[newSize];
            if (namespacePrefix != null) {
                System.arraycopy(namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
                System.arraycopy(namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
            }
            namespacePrefix = newNamespacePrefix;
            namespaceUri = newNamespaceUri;

            if (!allStringsInterned) {
                final int[] newNamespacePrefixHash = new int[newSize];
                if (namespacePrefixHash != null) {
                    System.arraycopy(namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
                }
                namespacePrefixHash = newNamespacePrefixHash;
            }
             
             
        }
    }

    protected void closeCircuit(Route route) {
        try {
            lock.lock();
            resumeOrStartConsumer(route.getConsumer());
            failures.set(0);
            success.set(0);
            lastFailure = 0;
            openedAt = 0;
            state.set(STATE_CLOSED);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    private static String formatDate(Date date) {
        if (date == null) {
            return null;
        }
        try {
            return new SimpleDateFormat(DATE_TIME_FORMAT).format(date);
        } catch (Exception e) {
            LOG.warn("Unable to format date '{}' using format {}", date, DATE_TIME_FORMAT, e);
        }

        return null;
    }

    public static void skipPreambleAndStartBoundary(AS2SessionInputBuffer inbuffer, InputStream is, String boundary)
            throws HttpException {

        boolean foundStartBoundary;
        try {
            foundStartBoundary = false;
            CharArrayBuffer lineBuffer = new CharArrayBuffer(1024);
            while (inbuffer.readLine(lineBuffer, is) != -1) {
                final ParserCursor cursor = new ParserCursor(0, lineBuffer.length());
                if (isBoundaryDelimiter(lineBuffer, cursor, boundary)) {
                    foundStartBoundary = true;
                    break;
                }
                lineBuffer.clear();
            }
        } catch (Exception e) {
            throw new HttpException("Failed to read start boundary for body part", e);
        }

        if (!foundStartBoundary) {
            throw new HttpException("Failed to find start boundary for body part");
        }

    }

    private Function<Exchange, Object> saveEdge() {
        return exchange -> {
            try {
                ArangoEdgeCollection edgeCollection = calculateEdgeCollection();
                Object edgeDocument = exchange.getMessage().getMandatoryBody();
                return edgeCollection.insertEdge(edgeDocument);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public KeyPair getKey(String keyId) throws Exception {
        if (keyCache.containsKey(keyId)) {
            return keyCache.get(keyId);
        }

        Path keyFile = getKeyFile(keyId);
        if (!Files.exists(keyFile)) {
            throw new IllegalArgumentException("Key not found: " + keyId);
        }

        try (ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(Files.newInputStream(keyFile)))) {
            KeyPair keyPair = (KeyPair) ois.readObject();
            keyCache.put(keyId, keyPair);
            return keyPair;
        }
    }

    public void interceptProperties(Map<String, Object> properties) {
        Map<String, String> endpointHttpHeaders = (Map<String, String>) properties.get(ENDPOINT_HTTP_HEADERS_PROPERTY);

         
        properties.put(EDM_PROPERTY, apiProxy.getEdm(endpointHttpHeaders));

         
        properties.put(FILTER_ALREADY_SEEN, configuration.isFilterAlreadySeen());

         
        final String keyPredicate = (String) properties.get(KEY_PREDICATE_PROPERTY);
        if (keyPredicate != null) {

             
            final String resourcePath = (String) properties.get(RESOURCE_PATH_PROPERTY);
            if (resourcePath == null) {
                throw new IllegalArgumentException(
                        "Resource path must be provided in endpoint URI, or URI parameter '" + RESOURCE_PATH_PROPERTY
                                                   + "', or exchange header '"
                                                   + Olingo2Constants.PROPERTY_PREFIX + RESOURCE_PATH_PROPERTY + "'");
            }

             
            properties.put(RESOURCE_PATH_PROPERTY, resourcePath + '(' + keyPredicate + ')');
        }

         
        parseQueryParams(properties);
    }

    public static <V, T extends Throwable> Supplier<V> wrapAsSupplier(ThrowingSupplier<V, T> supplier) {
        return new Supplier<>() {
            @Override
            public V get() {
                try {
                    return supplier.get();
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    public <K, V> BasicCache<K, V> getCache(String cacheName) {
        Cache<K, V> cache;
        if (ObjectHelper.isEmpty(cacheName) || CACHE_MANAGER_CURRENT.equals(cacheName)) {
            cache = cacheContainer.getCache();
        } else {
            cache = cacheContainer.getCache(cacheName);
        }

        return configuration.hasFlags()
                ? cache.getAdvancedCache().withFlags(configuration.getFlags())
                : cache;
    }

    private static GenericFileExclusiveReadLockStrategy getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy strategy
                = (GenericFileExclusiveReadLockStrategy) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<SftpRemoteFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                SftpChangedExclusiveReadLockStrategy readLockStrategy = new SftpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public Object getInstance(Message m) {
        Object result = null;
        if (provider != null) {
            result = provider.getInstance(m);
        } else {
             
            result = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz },
                    new SubResourceClassInvocationHandler());
        }
        return result;
    }

    protected void doStart() throws Exception {
        super.doStart();

         
        PropertiesComponent pc = camelContext.getPropertiesComponent();
        PropertiesFunction pf = pc.getPropertiesFunction("hashicorp");
        if (pf instanceof HashicorpVaultPropertiesFunction) {
            propertiesFunction = (HashicorpVaultPropertiesFunction) pf;
            LOG.debug("Auto-detecting secrets from properties-function: {}", pf.getName());
        }
         
        HashicorpVaultConfiguration hashicorpVaultConfiguration = getCamelContext().getVaultConfiguration().hashicorp();
        secrets = hashicorpVaultConfiguration.getSecrets();
        if (ObjectHelper.isEmpty(secrets) && propertiesFunction == null) {
            throw new IllegalArgumentException("Secrets must be configured on Hashicorp vault configuration");
        }

        String token = System.getenv(CAMEL_HASHICORP_VAULT_TOKEN_ENV);
        String host = System.getenv(CAMEL_HASHICORP_VAULT_HOST_ENV);
        String port = System.getenv(CAMEL_HASHICORP_VAULT_PORT_ENV);
        String scheme = System.getenv(CAMEL_HASHICORP_VAULT_SCHEME_ENV);
        if (System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV) != null) {
            cloud = Boolean.parseBoolean(System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV));
        }
        namespace = System.getenv(CAMEL_HASHICORP_VAULT_NAMESPACE_ENV);

        if (ObjectHelper.isEmpty(token) && ObjectHelper.isEmpty(host)
                && ObjectHelper.isEmpty(port) && ObjectHelper.isEmpty(scheme) && ObjectHelper.isEmpty(namespace)) {
            if (ObjectHelper.isNotEmpty(hashicorpVaultConfiguration)) {
                token = hashicorpVaultConfiguration.getToken();
                host = hashicorpVaultConfiguration.getHost();
                port = hashicorpVaultConfiguration.getPort();
                scheme = hashicorpVaultConfiguration.getScheme();
                cloud = hashicorpVaultConfiguration.isCloud();
                if (hashicorpVaultConfiguration.isCloud()) {
                    namespace = hashicorpVaultConfiguration.getNamespace();
                }
            }
        }

        if (ObjectHelper.isNotEmpty(token) && ObjectHelper.isNotEmpty(host)
                && ObjectHelper.isNotEmpty(port) && ObjectHelper.isNotEmpty(scheme)) {
            VaultEndpoint vaultEndpoint = new VaultEndpoint();
            vaultEndpoint.setHost(host);
            vaultEndpoint.setPort(Integer.parseInt(port));
            vaultEndpoint.setScheme(scheme);

            client = new VaultTemplate(
                    vaultEndpoint,
                    new TokenAuthentication(token));
        } else {
            throw new RuntimeCamelException(
                    "Using the Hashicorp Vault Secrets Refresh Task requires setting Token, Host, port and scheme properties");
        }
    }

    public PollingConsumer createPollingConsumer() throws Exception {
        JpaPollingConsumer consumer = new JpaPollingConsumer(this);
        consumer.setQuery(getQuery());
        consumer.setNamedQuery(getNamedQuery());
        consumer.setNativeQuery(getNativeQuery());
        consumer.setLockModeType(getLockModeType());
        consumer.setParameters(getParameters());
        consumer.setResultClass(getResultClass());
        return consumer;
    }

    private void initializeSdkClient(FaceRecognitionEndpoint endpoint, ClientConfigurations clientConfigurations) {
        if (endpoint.getFrsClient() != null) {
            LOG.info(
                    "Instance of FrsClient was set on the endpoint. Skip creation of FrsClient from endpoint parameters");
            this.frsClient = endpoint.getFrsClient();
            return;
        }
        HttpConfig httpConfig
                = HttpConfig.getDefaultHttpConfig().withIgnoreSSLVerification(clientConfigurations.isIgnoreSslVerification());
        if (!StringUtils.isEmpty(clientConfigurations.getProxyHost())) {
            httpConfig.setProxyHost(clientConfigurations.getProxyHost());
            httpConfig.setProxyPort(clientConfigurations.getProxyPort());
            if (!StringUtils.isEmpty(clientConfigurations.getProxyUser())) {
                httpConfig.setProxyUsername(clientConfigurations.getProxyUser());
                httpConfig.setProxyPassword(clientConfigurations.getProxyPassword());
            }
        }
        BasicCredentials credentials = new BasicCredentials().withAk(clientConfigurations.getAccessKey())
                .withSk(clientConfigurations.getSecretKey())
                .withProjectId(clientConfigurations.getProjectId());

        frsClient = FrsClient.newBuilder()
                .withCredential(credentials)
                .withHttpConfig(httpConfig)
                .withEndpoint(clientConfigurations.getEndpoint())
                .build();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully initialized FRS client");
        }
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public Optional<Class<?>> findOptionalClass(String key) {
        Class<?> clazz = addToClassMap(key, () -> {
            Properties prop = doFindFactoryProperties(key);
            if (prop != null) {
                return doNewInstance(prop, false).orElse(null);
            } else {
                return null;
            }
        });
        return Optional.ofNullable(clazz);
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForChanged(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileChangedExclusiveReadLockStrategy readLockStrategy = new FileChangedExclusiveReadLockStrategy();
        Long minLength = (Long) params.get("readLockMinLength");
        if (minLength != null) {
            readLockStrategy.setMinLength(minLength);
        }
        Long minAge = (Long) params.get("readLockMinAge");
        if (null != minAge) {
            readLockStrategy.setMinAge(minAge);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public void onBeginDownloading(String host, String file) {
        download = true;
        resume = false;
        resumeOffset = 0;
        watch.restart();
        interval.restart();
        String msg = "Downloading from host: " + host + " file: " + file + " starting ";  
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
        if (fileSize > 0) {
            msg += " (size: " + fileSizeText + ")";
        }
        doLog(msg);
    }

    private void createBucket(Exchange exchange, ClientConfigurations clientConfigurations) throws ObsException {
        CreateBucketRequest request = null;

         
        Object exchangeBody = exchange.getMessage().getBody();
        if (exchangeBody instanceof CreateBucketRequest) {
            request = (CreateBucketRequest) exchangeBody;
        } else if (exchangeBody instanceof String) {
            String strBody = (String) exchangeBody;
            try {
                request = new ObjectMapper().readValue(strBody, CreateBucketRequest.class);
            } catch (JsonProcessingException e) {
                LOG.warn(
                        "String request body must be a valid JSON representation of a CreateBucketRequest. Attempting to create a bucket from endpoint parameters");
            }
        }

         
        if (request == null) {
             
            if (ObjectHelper.isEmpty(clientConfigurations.getBucketName())) {
                LOG.error("No bucket name given");
                throw new IllegalArgumentException("Bucket name is mandatory to create bucket");
            }

             
            if (ObjectHelper.isEmpty(clientConfigurations.getBucketLocation())) {
                LOG.warn("No bucket location given, defaulting to '{}'", OBSConstants.DEFAULT_LOCATION);
                clientConfigurations.setBucketLocation(OBSConstants.DEFAULT_LOCATION);
            }
             
            OBSRegion.checkValidRegion(clientConfigurations.getBucketLocation());

            request = new CreateBucketRequest(clientConfigurations.getBucketName(), clientConfigurations.getBucketLocation());
        }

         
        ObsBucket response = obsClient.createBucket(request);
        exchange.getMessage().setBody(gson.toJson(response));
    }

    private void processQuery(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        final String sObjectQuery = getParameter(SOBJECT_QUERY, exchange, USE_BODY, NOT_OPTIONAL);
        final boolean streamQueryResults = getParameter(STREAM_QUERY_RESULT, exchange, IGNORE_BODY, IS_OPTIONAL, Boolean.class);

         
        setResponseClass(exchange);
        exchange.setProperty(RESPONSE_CLASS_PREFIX, "QueryRecords");

        if (streamQueryResults) {
            restClient.query(sObjectQuery, determineHeaders(exchange), processWithStreamResultCallback(exchange, callback));
        } else {
            restClient.query(sObjectQuery, determineHeaders(exchange), processWithResponseCallback(exchange, callback));
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            if (propertiesFunction.isUseDefaultInstance()) {
                root.put("login", "Default Instance");
            } else {
                root.put("login", "Service Account Key File");
            }
            GcpVaultConfiguration gcp = getCamelContext().getVaultConfiguration().getGcpVaultConfiguration();
            if (gcp != null) {
                root.put("refreshEnabled", gcp.isRefreshEnabled());
                root.put("refreshPeriod", gcp.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    public static SecretManagerServiceClient create(
            CamelContext context,
            GoogleSecretManagerConfiguration configuration)
            throws Exception {
        SecretManagerServiceClient secretManagerServiceClient = null;
        if (!Strings.isNullOrEmpty(configuration.getServiceAccountKey())) {
            InputStream resolveMandatoryResourceAsInputStream
                    = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configuration.getServiceAccountKey());
            Credentials myCredentials = ServiceAccountCredentials
                    .fromStream(resolveMandatoryResourceAsInputStream);
            SecretManagerServiceSettings settings = SecretManagerServiceSettings.newBuilder()
                    .setCredentialsProvider(FixedCredentialsProvider.create(myCredentials)).build();
            secretManagerServiceClient = SecretManagerServiceClient.create(settings);
        } else {
             
             
             
            SecretManagerServiceSettings settings = SecretManagerServiceSettings.newBuilder().build();
            secretManagerServiceClient = SecretManagerServiceClient.create(settings);
        }
        return secretManagerServiceClient;
    }

    protected Class<?> loadClass(String name, ClassLoader loader) {
        Class<?> answer = null;
        try {
            answer = ObjectHelper.loadClass(name, loader);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(name);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(name, ".", name);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && name.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = ObjectHelper.loadClass(name, loader);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    protected String getHttpURL(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    public KeyPair generateKeyPair(String algorithm, String keyId, Object parameterSpec) throws Exception {
        LOG.info("Generating key pair for algorithm: {}, keyId: {}", algorithm, keyId);

        KeyPairGenerator generator;
        String provider = determineProvider(algorithm);

        if (provider != null) {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm), provider);
        } else {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm));
        }

         
        if (parameterSpec != null) {
            if (parameterSpec instanceof AlgorithmParameterSpec) {
                generator.initialize((AlgorithmParameterSpec) parameterSpec, new SecureRandom());
            } else if (parameterSpec instanceof Integer) {
                generator.initialize((Integer) parameterSpec, new SecureRandom());
            }
        } else {
             
            AlgorithmParameterSpec defaultSpec = getDefaultParameterSpec(algorithm);
            if (defaultSpec != null) {
                generator.initialize(defaultSpec, new SecureRandom());
            } else {
                generator.initialize(getDefaultKeySize(algorithm), new SecureRandom());
            }
        }

        KeyPair keyPair = generator.generateKeyPair();

         
        KeyMetadata metadata = new KeyMetadata(keyId, algorithm);
        metadata.setDescription("Generated on " + new Date());

         
        storeKey(keyId, keyPair, metadata);

        LOG.info("Generated key pair in Vault: {}", metadata);
        return keyPair;
    }

    public String getStringOrDefault(final String key, final String defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable instanceof Boolean) {
            returnable = returnable.toString();
        } else if (returnable instanceof Number) {
            returnable = returnable.toString();
        }
        return (String) returnable;
    }

    public static Expression exchangeOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                 
                 
                Expression ognlExp = bean.createExpression(null, new Object[] { null, exchange, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "exchangeOgnl(" + ognl + ")";
            }
        };
    }

    private <T> T unmarshalResponse(InputStream response, Request request, TypeReference<T> typeRef)
            throws SalesforceException {
        T result = null;
        if (response != null) {
            try {
                result = objectMapper.readValue(response, typeRef);
            } catch (IOException e) {
                throw new SalesforceException(
                        String.format("Error unmarshalling response for {%s:%s} : %s",
                                request.getMethod(), request.getURI(), e.getMessage()),
                        e);
            }
        }
        return result;
    }

    public KeyPair importKey(byte[] keyData, KeyFormat format, String algorithm) throws Exception {
         
        try {
            PrivateKey privateKey = KeyFormatConverter.importPrivateKey(keyData, format, getAlgorithmName(algorithm));
             
             
            LOG.warn("Importing private key only - public key derivation may be needed");
            return new KeyPair(null, privateKey);
        } catch (Exception e) {
             
            PublicKey publicKey = KeyFormatConverter.importPublicKey(keyData, format, getAlgorithmName(algorithm));
            return new KeyPair(publicKey, null);
        }
    }

    private void doUpsert(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Upsert on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Upsert upsert = table.newUpsert();
        PartialRow row = upsert.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(upsert);
    }

    public void setSchema(String schema) {
        if (ObjectHelper.isNotEmpty(schema)) {
            try {
                this.schema = Json.mapper().readTree(schema);
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
        } else {
            this.schema = null;
        }
    }

    public void close() {
        if (!closed) {
            try {
                ClearScrollRequest clearScrollRequest = new ClearScrollRequest.Builder()
                        .scrollId(List.of(scrollId))
                        .build();

                esClient.clearScroll(clearScrollRequest);
                closed = true;
                exchange.setProperty(ElasticsearchConstants.PROPERTY_SCROLL_ES_QUERY_COUNT, requestCount);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

        protected void doStop() throws Exception {
            super.doStop();

            this.running.set(false);

            if (cache != null) {
                cache.removeClientListener(this);
            }

            getCamelContext().getExecutorServiceManager().shutdownGraceful(executorService);

            if (cache != null) {
                if (this.version != null) {
                    cache.removeWithVersion(InfinispanClusterService.LEADER_KEY, this.version);
                }

                LOGGER.info("Removing local member, key={}", getLocalMember().getId());
                cache.remove(getLocalMember().getId());
            }

            this.version = null;
        }

    private DaprOperationResponse waitForInstanceCompletion(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceCompletion(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be completed in " + timeout, exception);
        }
    }

    private void addRelevantProjectDependenciesToClasspath(List<URL> path, boolean testClasspathOnly)
            throws MojoExecutionException {
        try {
            getLog().debug("Project Dependencies will be included.");

            if (testClasspathOnly) {
                URL testClasses = new File(project.getBuild().getTestOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + testClasses);
                }
                path.add(testClasses);
            } else {
                URL mainClasses = new File(project.getBuild().getOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + mainClasses);
                }
                path.add(mainClasses);
            }

            Set<Artifact> dependencies = project.getArtifacts();

             
             
            dependencies.addAll(getAllNonTestScopedDependencies());

            for (Artifact classPathElement : dependencies) {
                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding project dependency artifact: " + classPathElement.getArtifactId()
                                   + " to classpath");
                }
                File file = classPathElement.getFile();
                if (file != null) {
                    path.add(file.toURI().toURL());
                }
            }

        } catch (MalformedURLException e) {
            throw new MojoExecutionException("Error during setting up classpath", e);
        }
    }

    public void configureProperties(Map<String, Object> options) {
         
        Map<String, Object> query = new CaseInsensitiveMap();
        Map<String, Object> known = new CaseInsensitiveMap();
        options.forEach((k, v) -> {
            if (k.startsWith("$")) {
                query.put(k, v);
            } else {
                known.put(k, v);
            }
        });
        options.keySet().removeIf(known::containsKey);

         
        PropertyConfigurer configurer = getComponent().getEndpointPropertyConfigurer();
        if (configurer instanceof ExtendedPropertyConfigurerGetter) {
            ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
            for (String name : getter.getAllOptions(this).keySet()) {
                if (known.containsKey(name)) {
                    Object value = known.get(name);
                    boolean hit = configurer.configure(getCamelContext(), this, name, value, true);
                    if (hit) {
                        known.remove(name);
                    }
                }
            }
        }
         
        configurer = PluginHelper.getConfigurerResolver(getCamelContext())
                .resolvePropertyConfigurer(configuration.getClass().getName(), getCamelContext());
        if (configurer != null) {
            PropertyBindingSupport.build()
                    .withConfigurer(configurer)
                    .withIgnoreCase(true)
                    .withTarget(configuration)
                    .withCamelContext(getCamelContext())
                    .withProperties(known)
                    .withRemoveParameters(true)
                    .bind();
        }
        super.configureProperties(known);
        if (!known.isEmpty()) {
             
            query.putAll(known);
        }
         
        options.keySet().removeIf(query::containsKey);
         
        parseQueryParams(query);
         
        options.putAll(query);
    }

    public static String camelCaseToDash(String text) {
        if (text == null || text.isEmpty()) {
            return text;
        }
        char prev = 0;

        char[] arr = text.toCharArray();
        StringBuilder answer = new StringBuilder(arr.length < 13 ? 16 : arr.length + 8);

        for (int i = 0; i < arr.length; i++) {
            char ch = arr[i];

            if (ch == '-' || ch == '_') {
                answer.append("-");
            } else {
                if (Character.isUpperCase(ch) && prev != 0) {
                    char next;

                    if (i < arr.length - 1) {
                        next = arr[i + 1];
                    } else {
                        next = 0;
                    }

                    if (!Character.isUpperCase(prev) || next != 0 && Character.isLowerCase(next)) {
                        applyDashPrefix(prev, answer, ch);
                    } else {
                        answer.append(Character.toLowerCase(ch));
                    }
                } else {
                    answer.append(Character.toLowerCase(ch));
                }
            }
            prev = ch;
        }

        return answer.toString();
    }

    private void deleteTranscriptionJob(TranscribeClient transcribeClient, Exchange exchange) throws InvalidPayloadException {
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof DeleteTranscriptionJobRequest) {
                try {
                    transcribeClient.deleteTranscriptionJob((DeleteTranscriptionJobRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Delete Transcription Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            }
        } else {
            DeleteTranscriptionJobRequest.Builder builder = DeleteTranscriptionJobRequest.builder();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(Transcribe2Constants.TRANSCRIPTION_JOB_NAME))) {
                String jobName = exchange.getIn().getHeader(Transcribe2Constants.TRANSCRIPTION_JOB_NAME, String.class);
                builder.transcriptionJobName(jobName);
            }
            try {
                transcribeClient.deleteTranscriptionJob(builder.build());
            } catch (AwsServiceException ase) {
                LOG.trace("Delete Transcription Job command returned the error code {}", ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if ("pom".equals(project.getPackaging())) {
            return;
        }

        if (sourcesOutputDir == null) {
            sourcesOutputDir = new File(project.getBasedir(), "src/generated/java");
        }
        if (resourcesOutputDir == null) {
            resourcesOutputDir = new File(project.getBasedir(), "src/generated/resources");
        }

        doExecute(sourcesOutputDir, resourcesOutputDir, classes, false);
    }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean hasNext = currentSearchHits.hasNext();
        if (!hasNext) {
            updateCurrentSearchHits();

            hasNext = currentSearchHits.hasNext();
        }

        return hasNext;
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

    protected <T> T doGetCache(String key, String name, Function<String, T> loader) {
        if (caching) {
            T t = (T) cache.get(key);
            if (t == null) {
                t = loader.apply(name);
                if (t != null) {
                    cache.put(key, t);
                }
            }
            return t;
        } else {
            return loader.apply(name);
        }
    }

    protected void findPackages(Set<String> packages, ClassLoader classLoader) throws IOException {
        Enumeration<URL> resources = classLoader.getResources(META_INF_SERVICES);
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            String path = url.getPath();
            if (!visitedURIs.contains(path)) {
                 
                visitedURIs.add(path);
                LOG.debug("Loading file {} to retrieve list of packages, from url: {}", META_INF_SERVICES, url);
                BufferedReader reader = IOHelper.buffered(new InputStreamReader(url.openStream(), UTF8));
                try {
                    while (true) {
                        String line = reader.readLine();
                        if (line == null) {
                            break;
                        }
                        line = line.trim();
                        if (line.startsWith("#") || line.isEmpty()) {
                            continue;
                        }
                        tokenize(packages, line);
                    }
                } finally {
                    IOHelper.close(reader, null, LOG);
                }
            }
        }
    }

    private String determineProvider(String algorithm) {
        try {
            PQCSignatureAlgorithms sigAlg = PQCSignatureAlgorithms.valueOf(algorithm);
            return sigAlg.getBcProvider();
        } catch (IllegalArgumentException e1) {
            try {
                PQCKeyEncapsulationAlgorithms kemAlg = PQCKeyEncapsulationAlgorithms.valueOf(algorithm);
                return kemAlg.getBcProvider();
            } catch (IllegalArgumentException e2) {
                return null;
            }
        }
    }

    private String getId(Row r) {
        if (r.first) {
            return "*-->";
        } else if (r.last) {
            return "*<--";
        } else {
            return r.nodeId;
        }
    }

    protected HazelcastInstance getOrCreateHzInstance(CamelContext context, Map<String, Object> parameters) throws Exception {
        HazelcastInstance hzInstance = null;
        Config config = null;

         
        hzInstance = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_INSTANCE_PARAM, HazelcastInstance.class);

         
        if (hzInstance == null && parameters.get(HAZELCAST_INSTANCE_NAME_PARAM) != null) {
            hzInstance = Hazelcast.getHazelcastInstanceByName((String) parameters.get(HAZELCAST_INSTANCE_NAME_PARAM));
        }

         
         
        if (hzInstance == null) {
            config = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_CONFIGU_PARAM, Config.class);
            if (config == null) {
                String configUri = getAndRemoveParameter(parameters, HAZELCAST_CONFIGU_URI_PARAM, String.class);
                if (configUri != null) {
                    configUri = getCamelContext().resolvePropertyPlaceholders(configUri);
                }
                if (configUri != null) {
                    InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configUri);
                    config = new XmlConfigBuilder(is).build();
                }
            }

            if (hazelcastInstance == null && config == null) {
                config = new XmlConfigBuilder().build();
                 
                config.getProperties().setProperty("hazelcast.version.check.enabled", "false");
                config.getProperties().setProperty("hazelcast.phone.home.enabled", "false");

                hzInstance = Hazelcast.newHazelcastInstance(config);
            } else if (config != null) {
                if (ObjectHelper.isNotEmpty(config.getInstanceName())) {
                    hzInstance = Hazelcast.getOrCreateHazelcastInstance(config);
                } else {
                    hzInstance = Hazelcast.newHazelcastInstance(config);
                }
            }

            if (hzInstance != null) {
                if (this.customHazelcastInstances.add(hzInstance)) {
                    LOGGER.debug("Add managed HZ instance {}", hzInstance.getName());
                }
            }
        }

        return hzInstance == null ? hazelcastInstance : hzInstance;
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            String port = IOHelper.lookupEnvironmentVariable(key + PORT_PREFIX);
            if (port != null) {
                return port;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    private RedeliveryPolicy resolveRedeliveryPolicy(DefaultErrorHandlerDefinition definition, CamelContext camelContext) {
        if (definition.hasRedeliveryPolicy() && definition.getRedeliveryPolicyRef() != null) {
            throw new IllegalArgumentException(
                    "Cannot have both redeliveryPolicy and redeliveryPolicyRef set at the same time.");
        }

        RedeliveryPolicy answer = null;
        RedeliveryPolicyDefinition def = definition.hasRedeliveryPolicy() ? definition.getRedeliveryPolicy() : null;
        if (def != null) {
            answer = ErrorHandlerReifier.createRedeliveryPolicy(def, camelContext, null);
        }
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
            answer = mandatoryLookup(definition.getRedeliveryPolicyRef(), RedeliveryPolicy.class);
        }
        if (answer == null) {
            answer = RedeliveryPolicy.DEFAULT_POLICY;
        }
        return answer;
    }

    protected JsonObject waitForOutputFile(Path outputFile) {
        StopWatch watch = new StopWatch();
        long wait = 10000;
        while (watch.taken() < wait) {
            File f = outputFile.toFile();
            try {
                 
                Thread.sleep(20);

                if (Files.exists(outputFile) && f.length() > 0) {
                    String text = Files.readString(outputFile);
                    return (JsonObject) Jsoner.deserialize(text);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                 
            }
        }
        return null;
    }

    private void deleteFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        Empty response = null;
        if (getConfiguration().isPojoRequest()) {
            DeleteFunctionRequest request = exchange.getIn().getMandatoryBody(DeleteFunctionRequest.class);
            response = client.deleteFunctionAsync(request).get();
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            DeleteFunctionRequest request = DeleteFunctionRequest.newBuilder().setName(cfName.toString()).build();
            response = client.deleteFunctionAsync(request).get();
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    protected String doBuildCamelEndpointUri(String host, Integer port, String contextPath, String scheme) {
        if (!ObjectHelper.equal(scheme, "netty-http")) {
            return super.doBuildCamelEndpointUri(host, port, contextPath, scheme);
        }

        String answer = scheme + ":http://" + host;
        if (port != null) {
            answer = answer + ":" + port;
        }

        if (contextPath != null) {
            if (!contextPath.startsWith("/")) {
                contextPath = "/" + contextPath;
            }

            answer += contextPath;
        }

        return answer;
    }

    protected void doStart() throws Exception {
        if (this.endpoint.getConfiguration() == null || this.endpoint.getConfiguration().getClientBuilder() == null) {
            client = SshClient.setUpDefaultClient();
        } else {
            client = this.endpoint.getConfiguration().getClientBuilder().build(true);
        }
        SshConfiguration configuration = endpoint.getConfiguration();
        configureAlgorithms(configuration, client);

        client.start();

        super.doStart();
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        JteEndpoint endpoint = new JteEndpoint(uri, this, remaining);
        endpoint.setAllowTemplateFromHeader(allowTemplateFromHeader);
        endpoint.setAllowContextMapAll(allowContextMapAll);
        endpoint.setContentCache(contentCache);

        setProperties(endpoint, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            endpoint.setResourceUri(remaining);
        }

        return endpoint;
    }

    public Object doMarshal(Exchange exchange, Object inputObject, OutputStream stream, String soapAction) throws IOException {
        Body body = objectFactory.createBody();
        Header header = objectFactory.createHeader();

        Throwable exception = exchange.getProperty(ExchangePropertyKey.EXCEPTION_CAUGHT, Throwable.class);
        if (exception == null) {
            exception = exchange.getIn().getHeader(Exchange.EXCEPTION_CAUGHT, Throwable.class);
        }

        final List<Object> bodyContent;
        List<Object> headerContent = new ArrayList<>();
        if (exception != null) {
            bodyContent = new ArrayList<>();
            bodyContent.add(createFaultFromException(exception));
        } else {
            if (!dataFormat.isIgnoreUnmarshalledHeaders()) {
                List<Object> inboundSoapHeaders
                        = (List<Object>) exchange.getIn().getHeader(SoapDataFormat.SOAP_UNMARSHALLED_HEADER_LIST);
                if (null != inboundSoapHeaders) {
                    headerContent.addAll(inboundSoapHeaders);
                }
            }
            bodyContent = getDataFormat().createContentFromObject(inputObject, soapAction);
        }

        for (Object elem : bodyContent) {
            body.getAny().add(elem);
        }
        for (Object elem : headerContent) {
            header.getAny().add(elem);
        }
        Envelope envelope = new Envelope();
        if (!headerContent.isEmpty()) {
            envelope.setHeader(header);
        }
        envelope.setBody(body);
        return objectFactory.createEnvelope(envelope);
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.storage.downloadTo");

        if (message.getHeaders().containsKey(GoogleCloudStorageConstants.BUCKET_NAME)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.storage.bucket." + message.getHeader(GoogleCloudStorageConstants.BUCKET_NAME, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getHeader(GoogleCloudStorageConstants.OBJECT_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
    }

    public MessageHistory newMessageHistory(String routeId, NamedNode node, Exchange exchange) {
        if (nodePattern != null) {
            String name = node.getShortName();
            String[] parts = nodePattern.split(",");
            for (String part : parts) {
                boolean match = PatternHelper.matchPattern(name, part);
                if (!match) {
                    return null;
                }
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        Timer timer = metricsRegistry.timer(createName("history", routeId, node.getId()));
        return new MetricsMessageHistory(routeId, node, timer, msg);
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    private void closeListeners(Exchange exchange, String message) {
        for (LogListener listener : listeners) {
            if (listener == null) {
                continue;
            }
            try {
                listener.afterLog(exchange, logger, message);
            } catch (Exception t) {
                LOG.warn("Ignoring an exception: {} thrown by: {} caused by: {}", t.getClass().getName(),
                        listener.getClass().getName(), t.getMessage());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("", t);
                }
            }
        }
    }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

    private CopyArchiveFromContainerCmd executeCopyFileContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Copy File/Folder Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);
        String resource = DockerHelper.getProperty(DockerConstants.DOCKER_RESOURCE, configuration, message, String.class);

        if (containerId == null || resource == null) {
            throw new IllegalArgumentException("Container ID and Resource must be specified");
        }

        CopyArchiveFromContainerCmd copyArchiveFromContainerCmd = client.copyArchiveFromContainerCmd(containerId, resource);

        String hostPath = DockerHelper.getProperty(DockerConstants.DOCKER_HOST_PATH, configuration, message, String.class);

        if (hostPath != null) {
            copyArchiveFromContainerCmd.withHostPath(hostPath);
        }

        return copyArchiveFromContainerCmd;

    }

    protected DataSetCallback resolveDataSetCallback(Exchange exchange) {
        if (exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_CALLBACK_HEADER) != null) {
            return (DataSetCallback) exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_CALLBACK_HEADER);
        } else if (getEndpoint().getDataSetCallback() != null) {
            return getEndpoint().getDataSetCallback();
        } else {
            throw new IllegalStateException("Cannot resolve DataSet callback.");
        }
    }

    public String getLastChosenProcessorId() {
        int idx = getProcessor().getLastChosenProcessorIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

        public Builder instance(Object instance) {
             
            if (instance instanceof Class) {
                this.beanType = (Class<?>) instance;
                this.instance = null;
            } else {
                this.beanType = null;
                this.instance = instance;
            }
            return this;
        }

    private void configureExecutorService(FaultToleranceProcessor processor, FaultToleranceConfigurationCommon config) {
        if (config.getThreadOffloadExecutorService() != null) {
            String ref = config.getThreadOffloadExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

        public Object next() {
            Object o = nextToken;
            try {
                nextToken = getNextToken();
            } catch (XMLStreamException e) {
                nextToken = null;
                throw new RuntimeException(e);
            }
            return o;
        }

    public static AS2ServerConnection createAS2ServerConnection(AS2Configuration configuration) throws IOException {
        try {
            return serverConnections.computeIfAbsent(
                    configuration.getServerPortNumber(),
                    key -> {
                        try {
                            return new AS2ServerConnection(
                                    configuration.getAs2Version(), configuration.getServer(),
                                    configuration.getServerFqdn(), configuration.getServerPortNumber(),
                                    configuration.getSigningAlgorithm(),
                                    configuration.getSigningCertificateChain(),
                                    configuration.getSigningPrivateKey(),
                                    configuration.getDecryptingPrivateKey(),
                                    configuration.getMdnMessageTemplate(),
                                    configuration.getValidateSigningCertificateChain(),
                                    configuration.getSslContext(),
                                    configuration.getMdnUserName(), configuration.getMdnPassword(),
                                    configuration.getMdnAccessToken());
                        } catch (IOException e) {
                            throw new UncheckedIOException(e);
                        }
                    });
        } catch (UncheckedIOException e) {
            throw e.getCause();
        }
    }

    public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        if (key == null || remappingFunction == null) {
            throw new NullPointerException();
        }
        for (;;) {
            SoftReference<V> ref = delegate.get(key);
            V oldValue = ref == null ? null : ref.get();
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue == null) {
                 
                if (ref != null && !delegate.remove(key, ref)) {
                     
                    continue;
                }
            } else if (ref == null) {
                if (delegate.putIfAbsent(key, new SoftReference<>(newValue)) != null) {
                     
                    continue;
                }
            } else if (!delegate.replace(key, ref, new SoftReference<>(newValue))) {
                 
                continue;
            }
            return newValue;
        }
    }

    private static void extractAttributes(Node xmlNode, RestVerbDetails detail) {
        NamedNodeMap map = xmlNode.getAttributes();
        detail.setPath(extractAttribute(map, "path"));
        detail.setConsumes(extractAttribute(map, "consumes"));
        detail.setProduces(extractAttribute(map, "produces"));
        detail.setApiDocs(extractAttribute(map, "apiDocs"));
        detail.setBindingMode(extractAttribute(map, "bindingMode"));
        detail.setClientRequestValidation(extractAttribute(map, "clientRequestValidation"));
        detail.setClientResponseValidation(extractAttribute(map, "clientResponseValidation"));
        detail.setSkipBindingOnErrorCode(extractAttribute(map, "skipBindingOnErrorCode"));
        detail.setType(extractAttribute(map, "type"));
        detail.setOutType(extractAttribute(map, "outType"));
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelRouteConfigurationContextFactoryBean) {
                CamelRouteConfigurationContextFactoryBean factoryBean = (CamelRouteConfigurationContextFactoryBean) value;
                builder.addPropertyValue("routeConfigurations", factoryBean.getRouteConfigurations());
            }

             
            injectNamespaces(element, binder);
        }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("azure")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("azure");
            if (pf instanceof KeyVaultPropertiesFunction) {
                propertiesFunction = (KeyVaultPropertiesFunction) pf;
            }
        }
        AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
        if (azure != null && azure.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(EventhubsReloadTriggerTask.class);
        }
    }

    protected void doOnInit(Route route) {
        QuartzComponent quartz = route.getCamelContext().getComponent("quartz", QuartzComponent.class);
        quartz.addScheduleInitTask(scheduler -> {
            setScheduler(scheduler);

             
             

            if (getRouteStopGracePeriod() == 0) {
                setRouteStopGracePeriod(10000);
            }

            if (getTimeUnit() == null) {
                setTimeUnit(TimeUnit.MILLISECONDS);
            }

             
            if (getRouteStartTime() == null && getRouteStopTime() == null && getRouteSuspendTime() == null
                    && getRouteResumeTime() == null) {
                throw new IllegalArgumentException(
                        "Scheduled Route Policy for route " + route.getId()
                                                   + " has no start/stop/suspend/resume times specified");
            }

            registerRouteToScheduledRouteDetails(route);
            if (getRouteStartTime() != null) {
                scheduleRoute(Action.START, route);
            }
            if (getRouteStopTime() != null) {
                scheduleRoute(Action.STOP, route);
            }

            if (getRouteSuspendTime() != null) {
                scheduleRoute(Action.SUSPEND, route);
            }
            if (getRouteResumeTime() != null) {
                scheduleRoute(Action.RESUME, route);
            }
        });
    }

    private void updatePids(Map<Long, Pid> rows) {
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Pid row = new Pid();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        Expression answer = null;
        if (block != null) {
            answer = block.createExpression(camelContext, expression);
        }
        if (answer == null) {
             
            answer = ExpressionBuilder.constantExpression("");
        }
        return answer;
    }

    public Producer createProducer() throws Exception {
        switch (subsystem) {
            case SwiftConstants.SWIFT_SUBSYSTEM_OBJECTS:
                return new ObjectProducer(this, createClient());
            case SwiftConstants.SWIFT_SUBSYSTEM_CONTAINERS:
                return new ContainerProducer(this, createClient());
            default:
                throw new IllegalArgumentException("Can't create producer with subsystem " + subsystem);
        }
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

    private CreateUpdateContainerOptions messageToCreateUpdateOptions(Message message) {
        CreateUpdateContainerOptions options = message.getBody(CreateUpdateContainerOptions.class);
        if (options == null) {
            Map<String, Object> headers = message.getHeaders();
            if (headers.containsKey(SwiftConstants.CONTAINER_METADATA_PREFIX)) {
                options = getCreateUpdateOptions(options)
                        .metadata(message.getHeader(SwiftConstants.CONTAINER_METADATA_PREFIX, Map.class));
            }

            if (headers.containsKey(SwiftConstants.VERSIONS_LOCATION)) {
                options = getCreateUpdateOptions(options)
                        .versionsLocation(message.getHeader(SwiftConstants.VERSIONS_LOCATION, String.class));
            }

            if (headers.containsKey(SwiftConstants.CONTAINER_READ)) {
                options = getCreateUpdateOptions(options)
                        .accessRead(message.getHeader(SwiftConstants.CONTAINER_READ, String.class));
            }

            if (headers.containsKey(SwiftConstants.CONTAINER_WRITE)) {
                options = getCreateUpdateOptions(options)
                        .accessWrite(message.getHeader(SwiftConstants.CONTAINER_WRITE, String.class));
            }
        }
        return options;
    }

    public Exchange receiveNoWait(Endpoint endpoint) {
        if (camelContext.isStopped()) {
            throw new RejectedExecutionException(CONTEXT_IS_STOPPED);
        }

        LOG.debug("<<<< {}", endpoint);
        PollingConsumer consumer = null;
        try {
            consumer = acquirePollingConsumer(endpoint);
            return consumer.receiveNoWait();
        } finally {
            if (consumer != null) {
                releasePollingConsumer(endpoint, consumer);
            }
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        InfluxDbEndpoint endpoint = new InfluxDbEndpoint(uri, this);
        endpoint.setConnectionBean(remaining);
        InfluxDB target = influxDB;
        if (target == null) {
             
            target = CamelContextHelper.mandatoryLookup(getCamelContext(), remaining, InfluxDB.class);
        }
        endpoint.setInfluxDB(target);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    public Consumer createConsumer(Processor processor) throws Exception {
        final Consumer consumer;
        if (isObserve()) {
            consumer = new CoAPObserver(this, processor);
        } else {
            consumer = new CoAPConsumer(this, processor);
        }
        configureConsumer(consumer);
        return consumer;
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

        String value = IOHelper.lookupEnvironmentVariable(key);
        return value != null ? value : defaultValue;
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(SourceDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    private String determineVectorBucketName(Exchange exchange) {
        String vectorBucketName = exchange.getIn().getHeader(AWS2S3VectorsConstants.VECTOR_BUCKET_NAME, String.class);
        if (vectorBucketName == null) {
            vectorBucketName = getConfiguration().getVectorBucketName();
        }
        if (vectorBucketName == null) {
            throw new IllegalArgumentException("Vector bucket name must be specified");
        }
        return vectorBucketName;
    }

    private static String getOutTypeName(String outType, Class<?> outTypeClass, String typeName) {
        String outTypeName = null;
        if (outTypeClass != null) {
            outTypeName = outTypeClass.isArray() ? outTypeClass.getComponentType().getName() : outTypeClass.getName();
        } else if (outType != null) {
            outTypeName = outType.endsWith("[]") ? outType.substring(0, outType.length() - 2) : outType;
        } else if (typeName != null) {
             
            outTypeName = typeName;
        }
        return outTypeName;
    }

    public static HttpString createMethod(Exchange exchange, UndertowEndpoint endpoint, boolean hasPayload)
            throws URISyntaxException {
         
         
        String queryString = exchange.getIn().getHeader(UndertowConstants.HTTP_QUERY, String.class);
         
        String uriString = exchange.getIn().getHeader(UndertowConstants.HTTP_URI, String.class);
         
        try {
            uriString = exchange.getContext().resolvePropertyPlaceholders(uriString);
        } catch (Exception e) {
            throw new RuntimeExchangeException("Cannot resolve property placeholders with uri: " + uriString, exchange, e);
        }
        if (uriString != null) {
            URI uri = new URI(uriString);
            queryString = uri.getQuery();
        }
        if (queryString == null) {
            queryString = endpoint.getHttpURI().getRawQuery();
        }

         
        HttpString answer;
        String m = exchange.getIn().getHeader(UndertowConstants.HTTP_METHOD, String.class);
        if (m != null) {
             
             
            m = m.toUpperCase();
            answer = new HttpString(m);
        } else if (queryString != null) {
             
            answer = Methods.GET;
        } else {
             
            answer = hasPayload ? Methods.POST : Methods.GET;
        }

        return answer;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jph = (JsonObject) root.get("platform-http");
                        if (jph != null) {
                            String server = jph.getString("server");
                            JsonArray arr = (JsonArray) jph.get("endpoints");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    JsonObject jo = (JsonObject) arr.get(i);
                                    row.server = server;
                                    row.url = jo.getString("url");
                                    row.path = jo.getString("path");
                                    row.verbs = jo.getString("verbs");
                                    row.consumes = jo.getString("consumes");
                                    row.produces = jo.getString("produces");
                                    rows.add(row);
                                }
                            }
                            if (all) {
                                arr = (JsonArray) jph.get("managementEndpoints");
                                if (arr != null) {
                                    for (int i = 0; i < arr.size(); i++) {
                                        row = row.copy();
                                        JsonObject jo = (JsonObject) arr.get(i);
                                        row.server = server;
                                        row.url = jo.getString("url");
                                        row.path = jo.getString("path");
                                        row.verbs = jo.getString("verbs");
                                        row.consumes = jo.getString("consumes");
                                        row.produces = jo.getString("produces");
                                        rows.add(row);
                                    }
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("URL").dataAlign(HorizontalAlign.LEFT).with(r -> r.url),
                    new Column().header("METHOD").dataAlign(HorizontalAlign.LEFT).with(r -> r.verbs),
                    new Column().header("CONTENT-TYPE").dataAlign(HorizontalAlign.LEFT).with(this::getContent))));
        }

        return 0;
    }

    public void stopView(String namespace) throws Exception {
        LockHelper.doWithWriteLockT(
                lock,
                () -> {
                    ViewHolder<T> holder = views.get(namespace);

                    if (holder != null) {
                        LOG.info("Force stop of view {}", namespace);
                        holder.stopView();
                    } else {
                        LOG.warn("Error forcing stop of view {}: it does not exist", namespace);
                    }
                });
    }

    protected void doStop() throws Exception {
        localLog.info("Stopping Google PubSub consumer for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());

        synchronized (subscribers) {
            if (!subscribers.isEmpty()) {
                localLog.info("Stopping subscribers for {}/{}", endpoint.getProjectId(), endpoint.getDestinationName());
                subscribers.forEach(AbstractApiService::stopAsync);
            }
        }

        safeCancelSynchronousPullResponses();

        if (executor != null) {
            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownGraceful(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;

        super.doStop();
    }

    public SchedulerFactory getSchedulerFactory() {
        if (schedulerFactory == null) {
            try {
                schedulerFactory = createSchedulerFactory();
            } catch (SchedulerException e) {
                throw new RuntimeException(e);
            }
        }
        return schedulerFactory;
    }

    private void runAsyncPull(Message message, DockerClient client, Exchange exchange) throws InterruptedException {
        try (PullImageCmd cmd = executePullImageRequest(client, message)) {

            PullImageResultCallback item = cmd.exec(new PullImageResultCallback() {
                @Override
                public void onNext(PullResponseItem item) {
                    super.onNext(item);

                    LOG.trace("pull image callback {}", item);

                }
            });

            setResponse(exchange, item);
        }
    }

    private Charset getEncodingParameter(String type, MinaConfiguration configuration) {
        String encoding = configuration.getEncoding();
        if (encoding == null) {
            encoding = Charset.defaultCharset().name();
             
            configuration.setEncoding(encoding);
            LOG.debug("{}: No encoding parameter using default charset: {}", type, encoding);
        }
        if (!Charset.isSupported(encoding)) {
            throw new IllegalArgumentException("The encoding: " + encoding + " is not supported");
        }

        return Charset.forName(encoding);
    }

        public void onPart(String channel, IRCUser user, String msg) {
            if (configuration.isOnPart()) {
                Exchange exchange = createOnPartExchange(channel, user, msg);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

  final public InParameter InParameter() throws ParseException {Token sqlTypeToken;
     String name = null;
     Token valueSrcToken;
     Integer scale = null;
     String typeName = null;
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case PARAMETER_NAME:{
      name = ParameterName();
      jj_consume_token(1);
      break;
      }
    default:
      jj_la1[3] = jj_gen;
      ;
    }
    sqlTypeToken = ParameterSqlType();
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case SCALE:{
      scale = Scale();
      break;
      }
    default:
      jj_la1[4] = jj_gen;
      ;
    }
    jj_consume_token(1);
    switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
    case PARAMETER_NAME:{
      typeName = ParameterName();
      jj_consume_token(1);
      break;
      }
    default:
      jj_la1[5] = jj_gen;
      ;
    }
    valueSrcToken = InParameterSrc();
int sqlType = ParseHelper.parseSqlType(sqlTypeToken, classResolver);

        {if ("" != null) return new InParameter(name == null ? createNextParameterName() : name, sqlType, valueSrcToken, scale, typeName);}
    throw new Error("Missing return statement in function");
}

    private void createCollection(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        WeaviateClass collection = WeaviateClass.builder().className(collectionName).build();

        Result<Boolean> res = client.misc().readyChecker().run();

        Result<Boolean> result = client.schema().classCreator().withClass(collection).run();
        populateResponse(result, exchange);

    }

        protected void decodeStructuredContent(Exchange exchange, Map<String, Object> content) {
            final CloudEvent ce = cloudEvent();
            final Message message = exchange.getIn();

             
            ifNotEmpty(content.remove("data"), message::setBody);

            ifNotEmpty(content.remove(ce.mandatoryAttribute(CloudEvent.CAMEL_CLOUD_EVENT_DATA_CONTENT_TYPE).json()), val -> {
                message.setHeader(Exchange.CONTENT_TYPE, val);
            });

            for (CloudEvent.Attribute attribute : ce.attributes()) {
                ifNotEmpty(content.remove(attribute.json()), val -> {
                    message.setHeader(attribute.id(), val);
                });
            }

             
             
             
            content.forEach((key, val) -> {
                message.setHeader(key.toLowerCase(Locale.US), val);
            });
        }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    public void releaseExclusiveReadLockOnCommit(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        Runnable r = () -> {
            if (removeOnCommit) {
                idempotentRepository.remove(exchange, key);
            } else {
                 
                idempotentRepository.confirm(exchange, key);
            }

            try {
                changed.releaseExclusiveReadLockOnCommit(operations, file, exchange);
            } catch (Exception e) {
                LOG.warn("Error during releasing exclusive read lock on rollback. This exception is ignored.", e);
            }
        };

        delayOrScheduleLockRelease(r);
    }

    private void doLoadKnownDependencies(String name) {
        try {
            Enumeration<URL> resources = getClass().getClassLoader().getResources(name);
            while (resources.hasMoreElements()) {
                URL resource = resources.nextElement();
                try (InputStream is = resource.openStream()) {
                    Properties prop = new Properties();
                    prop.load(is);
                    Map<String, String> map = new HashMap<>();
                    for (String key : prop.stringPropertyNames()) {
                        String value = prop.getProperty(key);
                        map.put(key, value);
                    }
                    addMappings(map);
                }
            }
        } catch (Exception e) {
             
        }
    }

    protected void doInit() throws Exception {
        super.doInit();

         
        if (getEndpoint().isSharedEntityManager()) {
            this.entityManager = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
        } else {
            this.entityManager = entityManagerFactory.createEntityManager();
        }
        LOG.trace("Created EntityManager {} on {}", entityManager, this);
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes Pods Consumer");
        if (executor != null) {
            KubernetesHelper.close(podsWatcher, podsWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    private ClientConfigurations initializeConfigurations(FaceRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();
        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        if (StringUtils.isEmpty(endpoint.getOperation())) {
            throw new IllegalArgumentException("operation needs to be set");
        }
        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

        public void parse(InputSource input) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(input);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    public void process(String uri, Function<? super Publisher<Exchange>, ?> processor) {
        try {
            context.addRoutes(new RouteBuilder() {
                @Override
                public void configure() throws Exception {
                    from(uri)
                            .process(exchange -> {
                                Exchange copy = exchange.copy();
                                Object result = processor.apply(Mono.just(copy));
                                exchange.getIn().setBody(result);
                            })
                            .process(unwrapStreamProcessorSupplier.get());
                }
            });
        } catch (Exception e) {
            throw new IllegalStateException("Unable to add reactive stream processor to the direct URI: " + uri, e);
        }
    }

    public void writeTo(OutputStream outstream) throws IOException {
        NoCloseOutputStream ncos = new NoCloseOutputStream(outstream);

         
        if (!isMainBody()) {
            try (CanonicalOutputStream canonicalOutstream = new CanonicalOutputStream(ncos, StandardCharsets.US_ASCII.name())) {

                for (Header header : getAllHeaders()) {
                    canonicalOutstream.writeln(header.toString());
                }
                canonicalOutstream.writeln();  
                                              
                                              
            }
        }

         
        String transferEncoding = getContentTransferEncoding() == null ? null : getContentTransferEncoding().getValue();
        try (OutputStream transferEncodedStream = EntityUtils.encode(ncos, transferEncoding)) {

            transferEncodedStream.write(compressedData);
        } catch (Exception e) {
            throw new IOException("Failed to write to output stream", e);
        }
    }

    protected Pattern createJsonMaskPattern(Set<String> keywords) {
        StringBuilder regex = createOneOfThemRegex(keywords);
        if (regex == null) {
            return null;
        }
        regex.insert(0, "\\\"(");
        regex.append(")\\\"(\\s*?):(\\s*?)\\\"([^\"]*)\\\"");

        if (LOG.isDebugEnabled()) {
            LOG.debug("JSon Pattern: {}", regex);
        }
        return Pattern.compile(regex.toString(), Pattern.CASE_INSENSITIVE);
    }

    private String doCreateCode(CamelContext camelContext, String expression) throws SimpleParserException {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final String leftExp = left.createCode(camelContext, expression);
        final String rightExp = right.createCode(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return leftExp + " && " + rightExp;
        } else if (operator == LogicalOperatorType.OR) {
            return leftExp + " || " + rightExp;
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    private void applyProducerSslConfiguration(Properties props) {
        if (securityProtocol.equals(SecurityProtocol.SSL.name()) || securityProtocol.equals(SecurityProtocol.SASL_SSL.name())) {
            addPropertyIfNotEmpty(props, CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, getSecurityProtocol());
            addPropertyIfNotNull(props, SslConfigs.SSL_KEY_PASSWORD_CONFIG, getSslKeyPassword());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG, getSslKeystoreLocation());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG, getSslKeystorePassword());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG, getSslTruststoreLocation());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG, getSslTruststorePassword());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_ENABLED_PROTOCOLS_CONFIG, getSslEnabledProtocols());
            addUpperCasePropertyIfNotEmpty(props, SslConfigs.SSL_KEYSTORE_TYPE_CONFIG, getSslKeystoreType());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_PROTOCOL_CONFIG, getSslProtocol());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_PROVIDER_CONFIG, getSslProvider());
            addUpperCasePropertyIfNotEmpty(props, SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG, getSslTruststoreType());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_CIPHER_SUITES_CONFIG, getSslCipherSuites());
            String algo = getSslEndpointAlgorithm();
            if (algo != null && !algo.equals("none") && !algo.equals("false")) {
                addPropertyIfNotNull(props, SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG, algo);
            }
            addPropertyIfNotEmpty(props, SslConfigs.SSL_KEYMANAGER_ALGORITHM_CONFIG, getSslKeymanagerAlgorithm());
            addPropertyIfNotEmpty(props, SslConfigs.SSL_TRUSTMANAGER_ALGORITHM_CONFIG, getSslTrustmanagerAlgorithm());
        }
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelRouteConfigurationContextFactoryBean) {
                CamelRouteConfigurationContextFactoryBean factoryBean = (CamelRouteConfigurationContextFactoryBean) value;
                builder.addPropertyValue("routeConfigurations", factoryBean.getRouteConfigurations());
            }

             
            injectNamespaces(element, binder);
        }

    private ZipArchiveEntry getNextEntry() throws IOException {
        ZipArchiveEntry entry;

        while ((entry = zipInputStream.getNextEntry()) != null) {
            if (!entry.isDirectory()) {
                return entry;
            } else {
                if (allowEmptyDirectory) {
                    return entry;
                }
            }
        }

        return null;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

    private String parseDestinationName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        int pos = uri.lastIndexOf(':');
        if (pos != -1) {
            return uri.substring(pos + 1);
        } else {
            return null;
        }
    }

    private void doUpdate(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Update on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Update update = table.newUpdate();
        PartialRow row = update.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(update);
    }

    private String getStatus(SuspendedRow r) {
        boolean remote = r.endpoint != null && r.endpoint.getBooleanOrDefault("remote", false);

        if (r.first) {
            String s = "Created";
            if (loggingColor) {
                return Ansi.ansi().fg(Ansi.Color.GREEN).a(s).reset().toString();
            } else {
                return s;
            }
        } else if (r.last) {
            String done = r.exception != null ? "Completed (exception)" : "Completed (success)";
            if (loggingColor) {
                return Ansi.ansi().fg(r.failed ? Ansi.Color.RED : Ansi.Color.GREEN).a(done).reset().toString();
            } else {
                return done;
            }
        }
        if (!r.done) {
            if (loggingColor) {
                return Ansi.ansi().fg(Ansi.Color.BLUE).a("Breakpoint").reset().toString();
            } else {
                return "Breakpoint";
            }
        } else if (r.failed) {
            String fail = r.exception != null ? "Exception" : "Failed";
            if (loggingColor) {
                return Ansi.ansi().fg(Ansi.Color.RED).a(fail).reset().toString();
            } else {
                return fail;
            }
        } else {
            String s = remote ? "Sent" : "Processed";
            if (loggingColor) {
                return Ansi.ansi().fg(Ansi.Color.GREEN).a(s).reset().toString();
            } else {
                return s;
            }
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public <T extends Enum<T>> T getEnumOrDefault(final String key, final T defaultValue) throws ClassNotFoundException {
         
        T returnable;
        final String value;
        final String[] splitValues;
        final int numberOfSplitValues;
        final StringBuilder returnTypeName;
        final StringBuilder enumName;
        final Class<T> returnType;
         
        if (this.containsKey(key)) {
             
            value = this.getStringOrDefault(key, "");
            if (value == null) {
                return null;
            }
             
            splitValues = value.split("\\.");
            numberOfSplitValues = splitValues.length;
            returnTypeName = new StringBuilder();
            enumName = new StringBuilder();
            for (int i = 0; i < numberOfSplitValues; i++) {
                if (i == (numberOfSplitValues - 1)) {
                     
                    enumName.append(splitValues[i]);
                } else if (i == (numberOfSplitValues - 2)) {
                     
                    returnTypeName.append(splitValues[i]);
                } else {
                     
                    returnTypeName.append(splitValues[i]);
                    returnTypeName.append(".");
                }
            }
             
            returnType = (Class<T>) Class.forName(returnTypeName.toString());
            returnable = Enum.valueOf(returnType, enumName.toString());
        } else {
             
            return defaultValue;
        }
        return returnable;
    }

    private Group messageToGroup(Message message) {
        Group group = message.getBody(Group.class);

        if (group == null) {
            Map headers = message.getHeaders();
            GroupBuilder builder = Builders.group();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(KeystoneConstants.DOMAIN_ID)) {
                builder.domainId(message.getHeader(KeystoneConstants.DOMAIN_ID, String.class));
            }

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            group = builder.build();
        }
        return group;
    }

    public XMLEventReader createXMLEventReader(InputStream in, Exchange exchange) throws XMLStreamException {
        XMLInputFactory factory = getInputFactory();
        try {
            String charsetName = ExchangeHelper.getCharsetName(exchange, false);
            if (charsetName == null) {
                return factory.createXMLEventReader(IOHelper.buffered(in));
            } else {
                return factory.createXMLEventReader(IOHelper.buffered(in), charsetName);
            }
        } finally {
            returnXMLInputFactory(factory);
        }
    }

    public HttpBinding getHttpBinding() {
         
        if (this.binding == null) {
            this.binding = new AttachmentHttpBinding();
            this.binding.setTransferException(isTransferException());
            this.binding.setMuteException(isMuteException());
            this.binding.setLogException(isLogException());
            if (getComponent() != null) {
                this.binding.setAllowJavaSerializedObject(getComponent().isAllowJavaSerializedObject());
            }
            this.binding.setHeaderFilterStrategy(getHeaderFilterStrategy());
            this.binding.setEagerCheckContentAvailable(isEagerCheckContentAvailable());
            this.binding.setMapHttpMessageBody(isMapHttpMessageBody());
            this.binding.setMapHttpMessageHeaders(isMapHttpMessageHeaders());
            this.binding.setMapHttpMessageFormUrlEncodedBody(isMapHttpMessageFormUrlEncodedBody());
        }
        return this.binding;
    }

    void processCompositeBatchResponse(
            final Exchange exchange, final Optional<SObjectBatchResponse> responseBody, final Map<String, String> headers,
            final SalesforceException exception, final AsyncCallback callback) {
        try {
            if (!responseBody.isPresent()) {
                exchange.setException(exception);
            } else {
                final Message in = exchange.getIn();
                final Message out = exchange.getOut();

                final SObjectBatchResponse response = responseBody.get();

                out.copyFromWithNewBody(in, response);
                out.getHeaders().putAll(headers);
            }
        } finally {
             
            callback.done(false);
        }
    }

    private void processGetReportInstances(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {

        final String reportId = getParameter(REPORT_ID, exchange, USE_BODY, NOT_OPTIONAL);

        analyticsClient.getReportInstances(reportId, determineHeaders(exchange),
                new AnalyticsApiClient.ReportInstanceListResponseCallback() {
                    @Override
                    public void onResponse(
                            List<ReportInstance> reportInstances, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, reportInstances, headers, ex, callback);
                    }
                });
    }

    private static Object asDefaultValue(String type, String defaultValue) {
        if (defaultValue != null) {
            if ("boolean".equals(type)) {
                return Boolean.parseBoolean(defaultValue);
            } else if ("integer".equals(type)) {
                return Integer.parseInt(defaultValue);
            }
        }
        if (defaultValue == null && "boolean".equals(type)) {
            return "false";
        }
        return defaultValue;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            stompEndpoint.send(exchange, callback);
            return false;
        } catch (Exception e) {
            exchange.setException(e);
        }
        callback.done(true);
        return true;
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (obj instanceof GenericArrayType) {
            return ((GenericArrayType) obj).getGenericComponentType().equals(componentType);
        } else {
            return false;
        }

    }

    private static boolean isAnalyticsOperation(OperationName operationName) {
        switch (operationName) {
            case GET_RECENT_REPORTS:
            case GET_REPORT_DESCRIPTION:
            case EXECUTE_SYNCREPORT:
            case EXECUTE_ASYNCREPORT:
            case GET_REPORT_INSTANCES:
            case GET_REPORT_RESULTS:
                return true;
            default:
                return false;
        }
    }

    public static Expression lowercaseExpression(final String expression) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                if (expression != null) {
                    exp = context.resolveLanguage("simple").createExpression(expression);
                    exp.init(context);
                }
            }

            @Override
            public Object evaluate(Exchange exchange) {
                String value;
                if (exp != null) {
                    value = exp.evaluate(exchange, String.class);
                } else {
                    value = exchange.getMessage().getBody(String.class);
                }
                if (value != null) {
                    value = value.toLowerCase(Locale.ENGLISH);
                }
                return value;
            }

            @Override
            public String toString() {
                if (expression != null) {
                    return "lowercase(" + expression + ")";
                } else {
                    return "lowercase()";
                }
            }
        };
    }

    private void listVoices(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        LOG.trace("Listing available voices");

        Voices voices = tts.listVoices().execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(voices.getVoices());
    }

        protected void doStop() throws Exception {
            super.doStop();

            this.running.set(false);

            if (cache != null) {
                cache.removeClientListener(this);
            }

            getCamelContext().getExecutorServiceManager().shutdownGraceful(executorService);

            if (cache != null) {
                if (this.version != null) {
                    cache.removeWithVersion(InfinispanClusterService.LEADER_KEY, this.version);
                }

                LOGGER.info("Removing local member, key={}", getLocalMember().getId());
                cache.remove(getLocalMember().getId());
            }

            this.version = null;
        }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            applySecurityPolicy(exchange);
        } catch (Exception e) {
             
            exchange.setException(e);
            callback.done(true);
            return true;
        }

        return super.process(exchange, callback);
    }

    protected boolean isMatched(
            Supplier<GenericFile<ShareFileItem>> file, String doneFileName,
            ShareFileItem[] files) {
        String onlyName = FileUtil.stripPath(doneFileName);

        for (ShareFileItem f : files) {
            if (f.getName().equals(onlyName)) {
                return true;
            }
        }

        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    private void updateUser(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        UpdateUserOption userOption;
        if (body instanceof UpdateUserOption) {
            userOption = (UpdateUserOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                userOption = new ObjectMapper().readValue(strBody, UpdateUserOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or UpdateUserOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getUserId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No user id given");
            }
            throw new IllegalArgumentException("User id is mandatory to update user");
        }

         
        UpdateUserRequestBody requestBody = new UpdateUserRequestBody()
                .withUser(userOption);
        UpdateUserRequest request = new UpdateUserRequest()
                .withBody(requestBody)
                .withUserId(clientConfigurations.getUserId());
        UpdateUserResponse response = iamClient.updateUser(request);
        exchange.getMessage().setBody(gson.toJson(response.getUser()));
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.mail.stream.consume");

        if (message.getHeaders().containsKey(GoogleMailStreamConstants.MAIL_FROM)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.mail.stream." + message.getHeader(GoogleMailStreamConstants.MAIL_FROM, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getHeader(GoogleMailStreamConstants.MAIL_SUBJECT, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public void getResults(
            String jobId, String batchId, Map<String, List<String>> headers, final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    private void update(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.updateEmbeddings(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    protected QueryFactory createQueryFactory() {
        if (query != null) {
            return QueryBuilder.query(query);
        } else if (namedQuery != null) {
            return QueryBuilder.namedQuery(namedQuery);
        } else if (nativeQuery != null) {
            if (resultClass != null) {
                return QueryBuilder.nativeQuery(nativeQuery, resultClass);
            } else {
                return QueryBuilder.nativeQuery(nativeQuery);
            }
        } else {
            Class<?> entityType = getEndpoint().getEntityType();

            if (entityType == null) {
                return null;
            } else {
                 
                String name = getEntityName(entityType);
                if (name != null) {
                    return QueryBuilder.query("select x from " + name + " x");
                } else {
                     
                    return QueryBuilder.query("select x from " + entityType.getSimpleName() + " x");
                }
            }
        }
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (obj instanceof GenericArrayType) {
            return ((GenericArrayType) obj).getGenericComponentType().equals(componentType);
        } else {
            return false;
        }

    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findLanguageNames()) {
            LanguageModel model = catalog.languageModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    public static BoxAPIConnection createAppEnterpriseAuthenticatedConnection(BoxConfiguration configuration) {
         
        JWTEncryptionPreferences encryptionPref = new JWTEncryptionPreferences();
        encryptionPref.setPublicKeyID(configuration.getPublicKeyId());

        try {
            encryptionPref.setPrivateKey(new String(Files.readAllBytes(Paths.get(configuration.getPrivateKeyFile()))));
        } catch (Exception e) {
            throw new RuntimeCamelException("Box API connection failed: could not read privateKeyFile", e);
        }

        encryptionPref.setPrivateKeyPassword(configuration.getPrivateKeyPassword());
        encryptionPref.setEncryptionAlgorithm(configuration.getEncryptionAlgorithm());

        IAccessTokenCache accessTokenCache = configuration.getAccessTokenCache();
        if (accessTokenCache == null) {
            accessTokenCache = new InMemoryLRUAccessTokenCache(configuration.getMaxCacheEntries());
        }

        try {
            return BoxDeveloperEditionAPIConnection.getAppEnterpriseConnection(configuration.getEnterpriseId(),
                    configuration.getClientId(), configuration.getClientSecret(), encryptionPref, accessTokenCache);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    String.format("Box API connection failed: API returned the error code %d%n%n%s",
                            e.getResponseCode(), e.getResponse()),
                    e);
        }

    }

    public static Expression bodyOgnlExpression(final String name, final String ognl) {
        return new ExpressionAdapter() {
            private ClassResolver classResolver;
            private Expression exp;
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                String text = exp.evaluate(exchange, String.class);
                Class<?> type;
                try {
                    type = classResolver.resolveMandatoryClass(text);
                } catch (ClassNotFoundException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                Object body = exchange.getIn().getBody(type);
                if (body != null) {
                     
                     
                    Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                    ognlExp.init(exchange.getContext());
                    return ognlExp.evaluate(exchange, Object.class);
                } else {
                    return null;
                }
            }

            @Override
            public void init(CamelContext context) {
                classResolver = context.getClassResolver();
                exp = ExpressionBuilder.simpleExpression(name);
                exp.init(context);
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnlAs[" + name + "](" + ognl + ")";
            }
        };
    }

    public <T extends ManagedConsumerMBean> T getManagedConsumer(String id, Class<T> type) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Route route = camelContext.getRoute(id);
        if (route != null) {
            try {
                Consumer consumer = route.getConsumer();
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy().getObjectNameForConsumer(camelContext,
                        consumer);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, type);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    private void executeDataFormat() throws MojoExecutionException {
         
        final String kind = "dataformat";
        List<String> dataFormatNames = listDescriptorNamesOfType(kind);

        final Set<File> jsonFiles = new TreeSet<>();
        PackageHelper.findJsonFiles(buildDir, jsonFiles);

         
        if (!dataFormatNames.isEmpty()) {
            if (getLog().isDebugEnabled()) {
                getLog().debug("Found " + dataFormatNames.size() + " dataformats");
            }

            for (String dataFormatName : dataFormatNames) {
                String json = loadJsonFrom(jsonFiles, kind, dataFormatName);
                if (json != null) {
                     
                    dataFormatName = asDataFormatName(dataFormatName);

                    File file = new File(dataformatDocDir, dataFormatName + "-" + kind + ".adoc");

                    DataFormatModel model = generateDataFormatModel(json);
                     
                     
                     
                    if ("bindy".equals(dataFormatName)) {
                        model.getOptions().stream().filter(o -> "type".equals(o.getName()))
                                .forEach(o -> o.setDefaultValue(null));
                    }

                    String title = asDataFormatTitle(model.getName(), model.getTitle());
                    model.setTitle(title);

                    boolean exists = file.exists();
                    boolean updated = updateHeader(dataFormatName, file, model, " DataFormat");
                    checkSince(file);

                    String options = evaluateTemplate("dataformat-options.mvel", model);
                    updated |= updateOptionsIn(file, kind, options);

                     
                     
                    if ("bindy".equals(dataFormatName)) {
                        updated |= updateAnnotationsIn(file);
                    }

                    if (updated) {
                        getLog().info("Updated doc file: " + file);
                    } else if (exists) {
                        if (getLog().isDebugEnabled()) {
                            getLog().debug("No changes to doc file: " + file);
                        }
                    } else {
                        getLog().warn("No dataformat doc file: " + file);
                        if (isFailFast()) {
                            throw new MojoExecutionException("Failed build due failFast=true");
                        }
                    }

                }
            }
        }
    }

    private void userSelectedHeadersMDC(Exchange exchange, boolean push) {
        for (String customHeader : getCustomHeaders().split(",")) {
            if (exchange.getIn().getHeader(customHeader) != null) {
                if (push) {
                    MDC.put(customHeader, exchange.getIn().getHeader(customHeader, String.class));
                } else {
                    MDC.remove(customHeader);
                }
            }
        }
    }

    public static BoxAPIConnection createAppUserAuthenticatedConnection(BoxConfiguration configuration) {
         
        JWTEncryptionPreferences encryptionPref = new JWTEncryptionPreferences();
        encryptionPref.setPublicKeyID(configuration.getPublicKeyId());

        try {
            encryptionPref.setPrivateKey(new String(Files.readAllBytes(Paths.get(configuration.getPrivateKeyFile()))));
        } catch (Exception e) {
            throw new RuntimeCamelException("Box API connection failed: could not read privateKeyFile", e);
        }

        encryptionPref.setPrivateKeyPassword(configuration.getPrivateKeyPassword());
        encryptionPref.setEncryptionAlgorithm(configuration.getEncryptionAlgorithm());

        IAccessTokenCache accessTokenCache = configuration.getAccessTokenCache();
        if (accessTokenCache == null) {
            accessTokenCache = new InMemoryLRUAccessTokenCache(configuration.getMaxCacheEntries());
        }

        try {
            return BoxDeveloperEditionAPIConnection.getUserConnection(configuration.getUserId(),
                    configuration.getClientId(), configuration.getClientSecret(), encryptionPref, accessTokenCache);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    String.format("Box API connection failed: API returned the error code %d%n%n%s",
                            e.getResponseCode(), e.getResponse()),
                    e);
        }

    }

    public Map<String, Object> endpointProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty() && isLenientProperties()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
             
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                boolean accept = knownProperties.contains(k);
                 
                 
                if (!accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().anyMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v);
                }
            });
        } else {
            properties = map;
        }

        return properties;
    }

    protected void doStart() throws Exception {
        if (useJmx) {
            ManagementAgent agent = getCamelContext().getManagementStrategy().getManagementAgent();
            if (agent != null) {
                MBeanServer server = agent.getMBeanServer();
                if (server != null) {
                    reporter = JmxReporter.forRegistry(metricsRegistry).registerWith(server).inDomain(jmxDomain).build();
                    reporter.start();
                }
            } else {
                throw new IllegalStateException("CamelContext has not enabled JMX");
            }
        }
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    public static void skipPreambleAndStartBoundary(AS2SessionInputBuffer inbuffer, InputStream is, String boundary)
            throws HttpException {

        boolean foundStartBoundary;
        try {
            foundStartBoundary = false;
            CharArrayBuffer lineBuffer = new CharArrayBuffer(1024);
            while (inbuffer.readLine(lineBuffer, is) != -1) {
                final ParserCursor cursor = new ParserCursor(0, lineBuffer.length());
                if (isBoundaryDelimiter(lineBuffer, cursor, boundary)) {
                    foundStartBoundary = true;
                    break;
                }
                lineBuffer.clear();
            }
        } catch (Exception e) {
            throw new HttpException("Failed to read start boundary for body part", e);
        }

        if (!foundStartBoundary) {
            throw new HttpException("Failed to find start boundary for body part");
        }

    }

    private void updateRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().get(roleName).update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update role requires POJO request with RoleRepresentation");
        }
    }

    public void onInvalidateAll(Message message) {

        Set<?> keys = message.getHeader(CaffeineConstants.KEYS, Set.class);
         
        if (keys == null) {
            cache.invalidateAll();
        } else {
            cache.invalidateAll(keys);
        }

        setResult(message, true, null, null);
    }

    public static Expression fileNameNoExtensionExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.stripExt(name);
            }

            @Override
            public String toString() {
                return "file:name.noext";
            }
        };
    }

    public void connect(HttpConsumer consumer) throws Exception {
         
        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) consumer.getEndpoint();
        String connectorKey = getConnectorKey(endpoint);

        try {
            CONNECTORS.compute(connectorKey, (cKey, connectorRef) -> {
                try {
                    return connect(consumer, endpoint, cKey, connectorRef);
                } catch (Exception e) {
                    throw new RuntimeCamelException(e);
                }
            });
        } catch (RuntimeCamelException e) {
            throw (Exception) e.getCause();
        }
    }

    public ApplicationPkcs7MimeCompressedDataEntity(MimeEntity entity2Encrypt,
                                                    CMSCompressedDataGenerator dataGenerator,
                                                    OutputCompressor compressor,
                                                    String compressedContentTransferEncoding,
                                                    boolean isMainBody)
                                                                        throws HttpException {
        super(ContentType.create("application/pkcs7-mime", new BasicNameValuePair("smime-type", "compressed-data"),
                new BasicNameValuePair("name", "smime.p7z")),
              compressedContentTransferEncoding);
        addHeader(AS2Header.CONTENT_DISPOSITION, CONTENT_DISPOSITION);
        setMainBody(isMainBody);
        try {
            this.compressedData = createCompressedData(entity2Encrypt, dataGenerator, compressor);
        } catch (Exception e) {
            throw new HttpException("Failed to create encrypted data");
        }
    }

    public HttpServerInitializerFactory(NettyHttpConsumer nettyConsumer) {
        this.consumer = nettyConsumer;
        this.configuration = nettyConsumer.getConfiguration();
        try {
            this.sslContext = createSSLContext(consumer.getContext(), consumer.getConfiguration());
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }

        if (sslContext != null) {
            LOG.info("Created SslContext {}", sslContext);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            Object newProperty = expression.evaluate(exchange, Object.class);

            if (exchange.getException() != null) {
                 
                callback.done(true);
                return true;
            }

            String key = propertyName.evaluate(exchange, String.class);
            exchange.setProperty(key, newProperty);
        } catch (Exception e) {
            exchange.setException(e);
        }

        callback.done(true);
        return true;
    }

    protected String resolvePropertyPlaceholders(String str) {
        try {
            if (getCamelContext() != null) {
                return getCamelContext().resolvePropertyPlaceholders(str);
            } else {
                return str;
            }
        } catch (Exception ex) {
            throw RuntimeCamelException.wrapRuntimeCamelException(ex);
        }
    }

        public void message(PubNub pubnub, PNMessageResult message) {
            Exchange exchange = createExchange(true);
            Message inmessage = exchange.getIn();
            inmessage.setBody(message);
            inmessage.setHeader(TIMETOKEN, message.getTimetoken());
            inmessage.setHeader(CHANNEL, message.getChannel());
            inmessage.setHeader(Exchange.MESSAGE_TIMESTAMP, message.getTimetoken());

            try {
                getProcessor().process(exchange);
            } catch (Exception e) {
                exchange.setException(e);
            }
            if (exchange.getException() != null) {
                getExceptionHandler().handleException("Error processing exchange", exchange.getException());
            }
        }

    private void doSelectOne(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            LOG.trace("SelectOne: {} using statement: {}", in, statement);
            result = session.selectOne(statement, in);
        } else {
            LOG.trace("SelectOne using statement: {}", statement);
            result = session.selectOne(statement);
        }

        doProcessResult(exchange, result, session);
    }

    private void doPublish(Exchange exchange, AsyncCallback callback) {
        Object body = exchange.getIn().getBody();
        if (ObjectHelper.isEmpty(body)) {
            throw new RuntimeCamelException("Cannot publish empty message");
        }
        LOG.debug("Sending message [{}] to channel [{}]", body, getChannel(exchange));
        endpoint.getPubnub()
                .publish()
                .message(body)
                .channel(getChannel(exchange))
                .usePOST(true)
                .async((Result<PNPublishResult> result) -> {
                    LOG.debug("Got publish message [{}]", result);
                    if (result.isFailure()) {
                        PubNubException ex = result.exceptionOrNull();
                        if (ex != null) {
                            exchange.setException(ex);
                        }
                        callback.done(false);
                    } else {
                        PNPublishResult r = result.getOrNull();
                        if (r != null) {
                            exchange.getIn().setHeader(PubNubConstants.TIMETOKEN, r.getTimetoken());
                        }
                        processMessage(exchange, callback, null);
                    }
                });
    }

    public Double toDouble(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.isFloatingPointNumber()) {
                return nn.asDouble();
            }
        }
        String text = node.asText();
        return Double.valueOf(text);
    }

                public void eventReceived(Action action, DeploymentConfig resource) {
                    DeploymentConfigEvent de = new DeploymentConfigEvent(action, resource);
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(de.getDeploymentConfig());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, de.getAction());
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    private String buildMetadataPath(String secretPath) {
        if (!cloud) {
            return secretsEngine + "/metadata/" + secretPath;
        } else {
            if (namespace != null && !namespace.isEmpty()) {
                return namespace + "/" + secretsEngine + "/metadata/" + secretPath;
            } else {
                return secretsEngine + "/metadata/" + secretPath;
            }
        }
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findDevConsoleNames()) {
            DevConsoleModel model = catalog.devConsoleModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    public InputStream resource(String path, Object resource, Map<String, Object> queryParams) {
        DeleteOperation deleteOperation = dhis2Client.delete(path);
        if (queryParams != null) {
            for (Map.Entry<String, Object> queryParam : queryParams.entrySet()) {
                if (queryParam.getValue() instanceof List) {
                    for (String queryValue : (List<String>) queryParam.getValue()) {
                        deleteOperation.withParameter(queryParam.getKey(), queryValue);
                    }
                } else {
                    deleteOperation.withParameter(queryParam.getKey(), (String) queryParam.getValue());
                }
            }
        }

        if (resource != null) {
            deleteOperation.withResource(resource);
        }

        return deleteOperation.transfer().read();

    }

    public void setInstance(Object instance) {
         
        if (instance instanceof Class) {
            this.beanType = (Class<?>) instance;
            this.instance = null;
        } else {
            this.beanType = null;
            this.instance = instance;
        }
    }

    private void doCreateOrUpdateServiceAccount(
            Exchange exchange, String operationName, Function<Resource<ServiceAccount>, ServiceAccount> operation) {
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ServiceAccount saToCreate
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SERVICE_ACCOUNT, ServiceAccount.class);
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Service Account require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Service Account require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(saToCreate)) {
            LOG.error("{} a specific Service Account require specify a Service Account bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Service Account require specify a Service Account bean", operationName));
        }
        ServiceAccount sa = operation.apply(getEndpoint().getKubernetesClient().serviceAccounts().inNamespace(namespaceName)
                .resource(saToCreate));

        prepareOutboundMessage(exchange, sa);
    }

    public RestDefinition consumes(String mediaType) {
        if (getVerbs().isEmpty()) {
            this.consumes = mediaType;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setConsumes(mediaType);
        }

        return this;
    }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

    public static Predicate or(final Predicate left, final Predicate right) {
        notNull(left, "left");
        notNull(right, "right");
        return new Predicate() {
            public boolean matches(Exchange exchange) {
                return left.matches(exchange) || right.matches(exchange);
            }

            @Override
            public void init(CamelContext camelContext) {
                left.initPredicate(camelContext);
                right.initPredicate(camelContext);
            }

            @Override
            public String toString() {
                return "(" + left + ") or (" + right + ")";
            }
        };
    }

    public BoxSharedLink createFileSharedLink(
            String fileId, BoxSharedLink.Access access, Date unshareDate,
            BoxSharedLink.Permissions permissions) {
        try {
            LOG.debug("Creating shared link for file(id={}) with access={} {}",
                    fileId, access, unshareDate == null
                            ? ""
                            : " unsharedDate=" + DateFormat.getDateTimeInstance().format(unshareDate)
                              + " permissions=" + permissions);

            BoxHelper.notNull(fileId, BoxHelper.FILE_ID);
            BoxHelper.notNull(access, "access");

            BoxFile file = new BoxFile(boxConnection, fileId);
            BoxSharedLinkRequest request = new BoxSharedLinkRequest();
            request.access(access).unsharedDate(unshareDate)
                    .permissions(permissions.getCanDownload(), permissions.getCanPreview(), permissions.getCanEdit());
            return file.createSharedLink(request);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(BoxHelper.buildBoxApiErrorMessage(e), e);
        }
    }

    List<Long> findPids(String name) {
        List<Long> pids = new ArrayList<>();

         
        if (name.matches("\\d+")) {
            return List.of(Long.parseLong(name));
        } else {
            if (name.endsWith("!")) {
                 
                name = name.substring(0, name.length() - 1);
            } else if (!name.endsWith("*")) {
                 
                name = name + "*";
            }
        }

        final long cur = ProcessHandle.current().pid();
        final String pattern = name;
        ProcessHandle.allProcesses()
                .filter(ph -> ph.pid() != cur)
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        String pName = ProcessHelper.extractName(root, ph);
                         
                        pName = FileUtil.onlyName(pName);
                        if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                            pids.add(ph.pid());
                        } else {
                             
                            JsonObject context = (JsonObject) root.get("context");
                            if (context != null) {
                                pName = context.getString("name");
                                if ("CamelJBang".equals(pName)) {
                                    pName = null;
                                }
                                if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                                    pids.add(ph.pid());
                                }
                            }
                        }
                    }
                });

        return pids;
    }

    private RemoveContainerCmd executeRemoveContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Remove Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        RemoveContainerCmd removeContainerCmd = client.removeContainerCmd(containerId);

        Boolean force = DockerHelper.getProperty(DockerConstants.DOCKER_FORCE, configuration, message, Boolean.class);

        if (force != null) {
            removeContainerCmd.withForce(force);
        }

        Boolean removeVolumes
                = DockerHelper.getProperty(DockerConstants.DOCKER_REMOVE_VOLUMES, configuration, message, Boolean.class);

        if (removeVolumes != null) {
            removeContainerCmd.withRemoveVolumes(removeVolumes);
        }

        return removeContainerCmd;

    }

    public InputStream loadResourceAsStream(String uri) {
        resourceResolverListeners.forEach(l -> l.onLoadResourceAsStream(uri));

        InputStream answer = null;
        try {
            answer = super.loadResourceAsStream(uri);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(uri);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(uri, ".", uri);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && uri.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = super.loadResourceAsStream(uri);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    protected void doStop() throws Exception {
        super.doStop();

        try {
            if (this.usm != null) {
                SecurityModels.getInstance().removeSecurityModel(new Integer32(this.usm.getID()));
            }
        } finally {
            this.targetAddress = null;
            this.usm = null;
            this.target = null;
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        CronJobList cronJobList;

        if (ObjectHelper.isEmpty(namespace)) {
            cronJobList = getEndpoint().getKubernetesClient().batch().v1().cronjobs().inAnyNamespace().list();
        } else {
            cronJobList = getEndpoint().getKubernetesClient().batch().v1().cronjobs().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, cronJobList.getItems());
    }

    public void afterPropertiesSet() {
        if (ObjectHelper.isEmpty(loggerId)) {
            log = LoggerFactory.getLogger(this.getClass().getName());
        } else {
            log = LoggerFactory.getLogger(loggerId);
        }

         
         
         

        log.trace("Project ID: {}", this.projectId);
        log.trace("Destination Name: {}", this.destinationName);
    }

    protected List<String> determineEncryptionUserIds(Exchange exchange) {
        String userid = findKeyUserid(exchange);
        List<String> userids = findKeyUserids(exchange);
         
        List<String> result;
        if (userid != null) {
            if (userids == null || userids.isEmpty()) {
                result = Collections.singletonList(userid);
            } else {
                result = new ArrayList<>(userids.size() + 1);
                result.add(userid);
                result.addAll(userids);
            }
        } else {
            if (userids == null || userids.isEmpty()) {
                throw new IllegalStateException("Cannot PGP encrypt message. No User ID of the public key specified.");
            }
            result = userids;
        }
        return result;
    }

    private SearchResponse<TDocument> firstSearch() {
        SearchResponse<TDocument> searchResponse;
        try {
            searchResponse = esClient.search(searchRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return searchResponse;
    }

    private void processCloseJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeJobState(jobId, JobStateEnum.UPLOAD_COMPLETE, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    public SecureRandomParameters getObject() throws Exception {
        if (this.isSingleton()) {
            if (instance == null) {
                instance = createInstance();
            }

            return instance;
        } else {
            return createInstance();
        }
    }

    public Long getLong(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).longValue();
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in Vault: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private <T> Optional<List<T>> tryToReadListResponse(
            final Class<T> expectedType, final InputStream responseStream) {
        if (responseStream == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(fromJsonList(expectedType, responseStream));
        } catch (IOException e) {
            log.warn("Unable to read response from the Composite API", e);
            return Optional.empty();
        } finally {
            IOHelper.close(responseStream);
        }
    }

    protected void configureDataGramCodecFactory(
            final String type, final IoService service, final MinaConfiguration configuration) {
        ProtocolCodecFactory codecFactory = configuration.getCodec();
        if (codecFactory == null) {
            codecFactory = new MinaUdpProtocolCodecFactory(this.getEndpoint().getCamelContext());

            if (LOG.isDebugEnabled()) {
                LOG.debug("{}: Using CodecFactory: {}", type, codecFactory);
            }
        }

        addCodecFactory(service, codecFactory);
    }

    protected int parseProlog() throws XmlPullParserException, IOException {
         
         

        char ch;
        if (seenMarkup) {
            ch = buf[pos - 1];
        } else {
            ch = more();
        }

        if (eventType == START_DOCUMENT) {
             
             
             
            if (ch == '\uFFFE') {
                throw new XmlPullParserException(
                        "first character in input was UNICODE noncharacter (0xFFFE)" + "- input requires int swapping", this,
                        null);
            }
            if (ch == '\uFEFF') {
                 
                ch = more();
            }
        }
        seenMarkup = false;
        boolean gotS = false;
        posStart = pos - 1;
        final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
        boolean normalizedCR = false;
        while (true) {
             
             
             
             
            if (ch == '<') {
                if (gotS && tokenize) {
                    posEnd = pos - 1;
                    seenMarkup = true;
                    return eventType = IGNORABLE_WHITESPACE;
                }
                ch = more();
                if (ch == '?') {
                     
                     
                    if (parsePI()) {  
                        if (tokenize) {
                            return eventType = PROCESSING_INSTRUCTION;
                        }
                    } else {
                         
                        posStart = pos;
                        gotS = false;
                    }

                } else if (ch == '!') {
                    ch = more();
                    if (ch == 'D') {
                        if (seenDocdecl) {
                            throw new XmlPullParserException("only one docdecl allowed in XML document", this, null);
                        }
                        seenDocdecl = true;
                        parseDocdecl();
                        if (tokenize)
                            return eventType = DOCDECL;
                    } else if (ch == '-') {
                        parseComment();
                        if (tokenize)
                            return eventType = COMMENT;
                    } else {
                        throw new XmlPullParserException("unexpected markup <!" + printable(ch), this, null);
                    }
                } else if (ch == '/') {
                    throw new XmlPullParserException("expected start tag name and not " + printable(ch), this, null);
                } else if (isNameStartChar(ch)) {
                    seenRoot = true;
                    return parseStartTag();
                } else {
                    throw new XmlPullParserException("expected start tag name and not " + printable(ch), this, null);
                }
            } else if (isS(ch)) {
                gotS = true;
                if (normalizeIgnorableWS) {
                    if (ch == '\r') {
                        normalizedCR = true;
                         
                         
                         
                        if (!usePC) {
                            posEnd = pos - 1;
                            if (posEnd > posStart) {
                                joinPC();
                            } else {
                                usePC = true;
                                pcStart = pcEnd = 0;
                            }
                        }
                         
                        if (pcEnd >= pc.length)
                            ensurePC(pcEnd);
                        pc[pcEnd++] = '\n';
                    } else if (ch == '\n') {
                        if (!normalizedCR && usePC) {
                            if (pcEnd >= pc.length)
                                ensurePC(pcEnd);
                            pc[pcEnd++] = '\n';
                        }
                        normalizedCR = false;
                    } else {
                        if (usePC) {
                            if (pcEnd >= pc.length)
                                ensurePC(pcEnd);
                            pc[pcEnd++] = ch;
                        }
                        normalizedCR = false;
                    }
                }
            } else {
                throw new XmlPullParserException(
                        "only whitespace content allowed before start tag and not " + printable(ch), this, null);
            }
            ch = more();
        }
    }

    protected KeyManagersParameters createInstance() throws Exception {
        KeyManagersParameters newInstance = new KeyManagersParameters();

        newInstance.setAlgorithm(algorithm);
        newInstance.setKeyPassword(keyPassword);
        if (getKeyStore() != null) {
            getKeyStore().setCamelContext(getCamelContext());
            newInstance.setKeyStore(getKeyStore().getObject());
        }
        newInstance.setProvider(provider);
        newInstance.setCamelContext(getCamelContext());

        return newInstance;
    }

    public static Expression mandatoryBodyOgnlExpression(final String name, final String ognl) {
        return new ExpressionAdapter() {
            private ClassResolver classResolver;
            private Expression exp;
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                String text = exp.evaluate(exchange, String.class);
                Class<?> type;
                try {
                    type = classResolver.resolveMandatoryClass(text);
                } catch (ClassNotFoundException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                Object body;
                try {
                    body = exchange.getIn().getMandatoryBody(type);
                } catch (InvalidPayloadException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                classResolver = context.getClassResolver();
                exp = ExpressionBuilder.simpleExpression(name);
                exp.init(context);
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "mandatoryBodyAs[" + name + "](" + ognl + ")";
            }
        };
    }

    protected void halfOpenCircuit(Route route) {
        try {
            lock.lock();
            resumeOrStartConsumer(route.getConsumer());
            state.set(STATE_HALF_OPEN);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    private String codeWithLineNumbers() {
        StringBuilder sb = new StringBuilder(256);
        String[] lines = code.split("\n");
        int counter = 0;
        for (String line : lines) {
            String s = String.format("%3d %s", ++counter, line);
            sb.append(s);
            sb.append("\n");
        }
        return sb.toString();
    }

    public Transformer resolve(TransformerKey key, CamelContext context) {
        String name = key.toString();
        TransformerModel model = catalog.transformerModel(name);
        if (model != null) {
            downloadLoader(model.getGroupId(), model.getArtifactId(), model.getVersion());
        }

        Transformer answer;
        boolean accept = accept(name);
        if (accept) {
            answer = super.resolve(key, context);
        } else {
            answer = new StubTransformer();
        }

        if (answer == null) {
            List<String> suggestion = SuggestSimilarHelper.didYouMean(catalog.findTransformerNames(), name);
            if (suggestion != null && !suggestion.isEmpty()) {
                String s = String.join(", ", suggestion);
                throw new IllegalArgumentException("Cannot find transformer with name: " + name + ". Did you mean: " + s);
            }
        }
        return answer;
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if ("pom".equals(project.getPackaging())) {
            return;
        }

        if (sourcesOutputDir == null) {
            sourcesOutputDir = new File(project.getBasedir(), "src/test/java");
        }
        if (resourcesOutputDir == null) {
            resourcesOutputDir = new File(project.getBasedir(), "src/test/resources");
        }

        doExecute(sourcesOutputDir, resourcesOutputDir, classes, true);
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    public static Predicate isGreaterThanOrEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceCompare(exchange.getContext().getTypeConverter(), leftValue, rightValue) >= 0;
            }

            protected String getOperationText() {
                return ">=";
            }
        };
    }

    private void getVoice(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        String voiceName = exchange.getIn().getHeader(WatsonTextToSpeechConstants.VOICE_NAME, String.class);
        if (voiceName == null) {
            voiceName = exchange.getIn().getBody(String.class);
        }

        if (voiceName == null || voiceName.isBlank()) {
            throw new IllegalArgumentException("Voice name must be specified");
        }

        LOG.trace("Getting voice information for: {}", voiceName);

        GetVoiceOptions options = new GetVoiceOptions.Builder()
                .voice(voiceName)
                .build();

        Voice voice = tts.getVoice(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(voice);
    }

    public static <T> Supplier<T> memorize(Supplier<T> supplier) {
        final AtomicReference<T> valueHolder = new AtomicReference<>();
        return new Supplier<>() {
            @Override
            public T get() {
                T supplied = valueHolder.get();
                if (supplied == null) {
                    synchronized (valueHolder) {
                        supplied = valueHolder.get();
                        if (supplied == null) {
                            supplied = Objects.requireNonNull(supplier.get(), "Supplier should not return null");
                            valueHolder.lazySet(supplied);
                        }
                    }
                }
                return supplied;
            }
        };
    }

    private static int getIndex(ParameterizedType type, TypeVariable<?> variable) {
        Type[] actualTypeArguments = type.getActualTypeArguments();
        for (int i = 0; i < actualTypeArguments.length; i++) {
            if (actualTypeArguments[i] instanceof TypeVariable) {
                TypeVariable<?> variableArgument = (TypeVariable<?>) actualTypeArguments[i];
                if (variableArgument.getName().equals(variable.getName())) {
                    return i;
                }
            }
        }
        return -1;
    }

    public BlacklistServiceCallServiceFilterConfiguration servers(String servers) {
        if (ObjectHelper.isNotEmpty(servers)) {
            String[] parts = servers.split(",");

            if (this.servers == null) {
                this.servers = new ArrayList<>();
            }

            this.servers.addAll(Arrays.asList(parts));
        }

        return this;
    }

    public static MultipartSignedEntity parseMultipartSignedEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String micalg,
            String charsetName,
            String contentTransferEncoding)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            NameValuePair[] parameters = new NameValuePair[] {
                    new BasicNameValuePair("protocol", AS2MimeType.APPLICATION_PKCS7_SIGNATURE),
                    new BasicNameValuePair("boundary", boundary), new BasicNameValuePair("micalg", micalg),
                    new BasicNameValuePair("charset", charsetName) };
            ContentType contentType = ContentType.create(AS2MimeType.MULTIPART_SIGNED, parameters);
             
             
            MultipartSignedEntity multipartSignedEntity
                    = new MultipartSignedEntity(contentType, contentTransferEncoding, boundary, false);  

             
            skipPreambleAndStartBoundary(inbuffer, is, boundary);

             
             
             

             
            Header[] headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType signedEntityContentType = null;
            String signedEntityContentTransferEncoding = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    signedEntityContentType = ContentType.parse(header.getValue());
                } else if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TRANSFER_ENCODING)) {
                    signedEntityContentTransferEncoding = header.getValue();
                }
            }
            if (signedEntityContentType == null) {
                throw new HttpException("Failed to find Content-Type header in signed entity body part");
            }

            MimeEntity signedEntity = parseEntityBody(inbuffer, is, boundary, signedEntityContentType,
                    signedEntityContentTransferEncoding, "", headers);
            signedEntity.removeAllHeaders();
            signedEntity.setHeaders(headers);
            multipartSignedEntity.addPart(signedEntity);

             
             

             
             
             

             
            headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType signatureContentType = null;
            String signatureContentTransferEncoding = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    signatureContentType = ContentType.parse(header.getValue());
                } else if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TRANSFER_ENCODING)) {
                    signatureContentTransferEncoding = header.getValue();
                }
            }
            if (signatureContentType == null) {
                throw new HttpException("Failed to find Content-Type header in signature body part");
            }
            if (!ContentTypeUtils.isPkcs7SignatureType(signatureContentType)) {
                throw new HttpException(
                        "Invalid content type '" + signatureContentType.getMimeType() + "' for signature body part");
            }

            ApplicationPkcs7SignatureEntity applicationPkcs7SignatureEntity = parseApplicationPkcs7SignatureEntityBody(inbuffer,
                    is, boundary, signatureContentType, signatureContentTransferEncoding);
            applicationPkcs7SignatureEntity.removeAllHeaders();
            applicationPkcs7SignatureEntity.setHeaders(headers);
            multipartSignedEntity.addPart(applicationPkcs7SignatureEntity);

             
             

            return multipartSignedEntity;

        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse text entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    private String getLoad(Row r) {
        String s1 = r.load01 != null ? r.load01 : "-";
        String s2 = r.load05 != null ? r.load05 : "-";
        String s3 = r.load15 != null ? r.load15 : "-";
        if ("0.00".equals(s1)) {
            s1 = "-";
        }
        if ("0.00".equals(s2)) {
            s2 = "-";
        }
        if ("0.00".equals(s3)) {
            s3 = "-";
        }
        if (s1.equals("-") && s2.equals("-") && s3.equals("-")) {
            return "0/0/0";
        }
        return s1 + "/" + s2 + "/" + s3;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            invokeOperation(configurationOptionsProxy.getOperation(exchange), exchange, callback);
            return false;
        } catch (Exception e) {
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    public Integer doCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        if (pids.isEmpty()) {
            return 0;
        } else if (pids.size() > 1) {
            printer().println("Name or pid " + name + " matches " + pids.size()
                              + " running Camel integrations. Specify a name or PID that matches exactly one.");
            return 0;
        }

        this.pid = pids.get(0);

         
        Path outputFile = getOutputFile(Long.toString(pid));
        PathUtils.deleteFile(outputFile);

        JsonObject root = new JsonObject();
        root.put("action", "route-structure");
        root.put("filter", "*");
        root.put("brief", brief);
        Path file = getActionFile(Long.toString(pid));
        try {
            Files.writeString(file, root.toJson());
        } catch (Exception e) {
             
        }

        JsonObject jo = waitForOutputFile(outputFile);
        if (jo != null) {
            JsonArray arr = (JsonArray) jo.get("routes");
            for (int i = 0; i < arr.size(); i++) {
                JsonObject o = (JsonObject) arr.get(i);
                Row row = new Row();
                row.location = extractSourceName(o.getString("source"));
                row.routeId = o.getString("routeId");
                if (!rows.contains(row)) {
                    List<JsonObject> lines = o.getCollection("code");
                    if (lines != null) {
                        for (JsonObject line : lines) {
                            Code code = new Code();
                            code.line = line.getInteger("line");
                            code.type = line.getString("type");
                            code.id = line.getString("id");
                            code.level = line.getInteger("level");
                            code.code = line.getString("code");
                            row.code.add(code);
                        }
                    }
                    boolean add = true;
                    if (filter != null) {
                        String f = filter;
                        boolean negate = filter.startsWith("-");
                        if (negate) {
                            f = f.substring(1);
                        }
                         
                        if (!f.endsWith("*")) {
                            f += "*";
                        }
                        boolean match
                                = PatternHelper.matchPattern(row.location, f) || PatternHelper.matchPattern(row.routeId, f);
                        if (negate) {
                            match = !match;
                        }
                        if (!match) {
                            add = false;
                        }
                    }
                    if (add) {
                        rows.add(row);
                    }
                }
            }
        } else {
            printer().println("Response from running Camel with PID " + pid + " not received within 5 seconds");
            return 1;
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printSource(rows);
        }

         
        PathUtils.deleteFile(outputFile);

        return 0;
    }

        public Destination resolveDestinationName(
                Session session, String destinationName,
                boolean pubSubDomain)
                throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.resolveDestinationName(session, destinationName, pubSubDomain);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    protected String doBuildCamelEndpointUri(String host, Integer port, String contextPath, String scheme) {
        if (!ObjectHelper.equal(scheme, "undertow")) {
            return super.doBuildCamelEndpointUri(host, port, contextPath, scheme);
        }

        String answer = scheme + ":http://" + host;
        if (port != null) {
            answer = answer + ":" + port;
        }

        if (contextPath != null) {
            if (!contextPath.startsWith("/")) {
                contextPath = "/" + contextPath;
            }

            answer += contextPath;
        }

        return answer;
    }

    private void callFunction(CloudFunctionsServiceClient client, Exchange exchange) throws InvalidPayloadException {
        CallFunctionResponse response = null;
        if (getConfiguration().isPojoRequest()) {
            CallFunctionRequest request = exchange.getIn().getMandatoryBody(CallFunctionRequest.class);
            response = client.callFunction(request);
        } else {
            String data = exchange.getIn().getBody(String.class);
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            CallFunctionRequest request = CallFunctionRequest.newBuilder().setName(cfName.toString()).setData(data)
                    .build();
            response = client.callFunction(request);
        }
        Message message = getMessageForResponse(exchange);
        message.setHeader(GoogleCloudFunctionsConstants.RESPONSE_OBJECT, response);
        message.setBody(response.getResult());
    }

    protected String getDelta(Row r) {
        if (r.delta != null) {
            if (r.delta.startsWith("-")) {
                return r.delta;
            } else if (!"0".equals(r.delta)) {
                 
                return "+" + r.delta;
            }
        }
        return r.delta;
    }

    public PathHandler removeExactPath(final String path) {
        lock.lock();
        try {
            super.removeExactPath(path);
            handlers.remove(path);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (len > 0) {
            answer.addAll(Arrays.asList(filters));
        }
        if (otherwise != null) {
            answer.add(otherwise);
        }
        return answer;
    }